more general check_matching_dims (#1936)

* more general check_matching_dims

* use dims()

* [Jenkins] auto-formatting by clang-format version 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

* fix overload issue in opencl/dims

* [Jenkins] auto-formatting by clang-format version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

Co-authored-by: Jenkins <nobody@nowhere>
Co-authored-by: Stan Jenkins <[email protected]>
Co-authored-by: rok-cesnovar <[email protected]>

Author: 4 people

stan/math/opencl/prim/dims.hpp

@@ -2,24 +2,26 @@
 #define STAN_MATH_OPENCL_PRIM_DIMS_HPP
 #ifdef STAN_OPENCL
 
+#include <stan/math/prim/fun/dims.hpp>
 #include <stan/math/opencl/matrix_cl.hpp>
 #include <stan/math/opencl/rev/matrix_cl.hpp>
 #include <vector>
 
 namespace stan {
 namespace math {
 /** \ingroup opencl
- * Returns a vector of matrix_cl dimensions.
+ * matrix_cl overload of the dims helper function in prim/fun/dims.hpp.
+ * Pushes the rows and columns to the result vector argument.
  *
  * @tparam T_x type of input kernel generator expression a
- * @param x the input matrix_cl
- *
- * @return std::vector of the dimensions of the input kernel generato expression
+ * @param[in] x the input matrix_cl
+ * @param[out] result the output vector of dimensions
  */
 template <typename T_x,
-          typename = require_all_kernel_expressions_and_none_scalar_t<T_x>>
-inline std::vector<int> dims(const T_x& x) {
-  return {x.rows(), x.cols()};
+          require_all_kernel_expressions_and_none_scalar_t<T_x>* = nullptr>
+inline void dims(const T_x& x, std::vector<int>& result) {
+  result.push_back(x.rows());
+  result.push_back(x.cols());
 }
 }  // namespace math
 }  // namespace stan

stan/math/prim/err/check_matching_dims.hpp

@@ -3,7 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/err/check_size_match.hpp>
+#include <stan/math/prim/fun/dims.hpp>
 #include <stan/math/prim/err/invalid_argument.hpp>
 #include <sstream>
 #include <string>
@@ -70,6 +70,56 @@ inline void check_matching_dims(const char* function, const char* name1,
   check_matching_dims(function, name1, y1, name2, y2);
 }
 
+/**
+ * Check if the two containers have the same dimensions.
+ * @tparam T1 type of the first container
+ * @tparam T2 type of the second container
+ * @param function name of function (for error messages)
+ * @param name1 variable name for the first container (for error messages)
+ * @param y1 first container to test
+ * @param name2 variable name for the second container (for error messages)
+ * @param y2 second container to test
+ * @throw <code>std::invalid_argument</code> if the dimensions of the
+ *    containers do not match
+ */
+template <typename T1, typename T2, require_all_std_vector_t<T1, T2>* = nullptr>
+inline void check_matching_dims(const char* function, const char* name1,
+                                const T1& y1, const char* name2, const T2& y2) {
+  std::vector<int> y1_d = dims(y1);
+  std::vector<int> y2_d = dims(y2);
+  bool error = false;
+  if (y1_d.size() != y2_d.size()) {
+    error = true;
+  } else {
+    for (int i = 0; i < y1_d.size(); i++) {
+      if (y1_d[i] != y2_d[i]) {
+        error = true;
+        break;
+      }
+    }
+  }
+  if (error) {
+    std::ostringstream y1s;
+    if (y1_d.size() > 0) {
+      y1s << y1_d[0];
+      for (int i = 1; i < y1_d.size(); i++) {
+        y1s << ", " << y1_d[i];
+      }
+    }
+    std::ostringstream msg;
+    msg << ") and " << name2 << " (";
+    if (y2_d.size() > 0) {
+      msg << y2_d[0];
+      for (int i = 1; i < y2_d.size(); i++) {
+        msg << ", " << y2_d[i];
+      }
+    }
+    msg << ") must match in size";
+    std::string msg_str(msg.str());
+    invalid_argument(function, name1, y1s.str(), "(", msg_str.c_str());
+  }
+}
+
 }  // namespace math
 }  // namespace stan
 #endif

test/unit/math/prim/err/check_matching_dims_test.cpp

@@ -27,6 +27,50 @@ TEST(ErrorHandlingMatrix, checkMatchingDimsMatrix) {
       std::invalid_argument);
 }
 
+TEST(ErrorHandlingMatrix, checkMatchingDimsArray) {
+  std::vector<double> y(3);
+  std::vector<double> x(3);
+
+  EXPECT_NO_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y));
+  x.resize(0);
+  y.resize(0);
+  EXPECT_NO_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y));
+
+  y.resize(1);
+  EXPECT_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y),
+      std::invalid_argument);
+
+  x.resize(2);
+  EXPECT_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y),
+      std::invalid_argument);
+}
+
+TEST(ErrorHandlingMatrix, checkMatchingDimsVectorArray) {
+  std::vector<Eigen::VectorXd> y(3, Eigen::VectorXd(3));
+  std::vector<Eigen::VectorXd> x(3, Eigen::VectorXd(3));
+
+  EXPECT_NO_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y));
+  x.resize(0);
+  y.resize(0);
+  EXPECT_NO_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y));
+
+  y.resize(1, Eigen::VectorXd(3));
+  EXPECT_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y),
+      std::invalid_argument);
+
+  x.resize(1, Eigen::VectorXd(2));
+  EXPECT_THROW(
+      stan::math::check_matching_dims("checkMatchingDims", "x", x, "y", y),
+      std::invalid_argument);
+}
+
 TEST(ErrorHandlingMatrix, checkMatchingDimsMatrix_nan) {
   Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> y;
   Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> x;