Merge pull request #1225 from bstatcomp/feature/issue-1217-change-name-of-copy-function

Feature/issue 1217 change name of copy function

Author: seantalts

stan/math/opencl/copy.hpp

@@ -1,5 +1,5 @@
-#ifndef STAN_MATH_PRIM_MAT_FUN_OPENCL_COPY_HPP
-#define STAN_MATH_PRIM_MAT_FUN_OPENCL_COPY_HPP
+#ifndef STAN_MATH_OPENCL_COPY_HPP
+#define STAN_MATH_OPENCL_COPY_HPP
 #ifdef STAN_OPENCL
 
 #include <stan/math/opencl/opencl_context.hpp>
@@ -28,21 +28,16 @@ namespace math {
  * the destination matrix that is stored
  * on the OpenCL device.
  *
- * @tparam T type of data in the Eigen matrix
- * @param dst destination matrix on the OpenCL device
+ * @tparam R Compile time rows of the Eigen matrix
+ * @tparam C Compile time columns of the Eigen matrix
  * @param src source Eigen matrix
- *
- * @throw <code>std::invalid_argument</code> if the
- * matrices do not have matching dimensions
+ * @return matrix_cl with a copy of the data in the source matrix
  */
 template <int R, int C>
-void copy(matrix_cl& dst, const Eigen::Matrix<double, R, C>& src) {
-  check_size_match("copy (Eigen -> (OpenCL))", "src.rows()", src.rows(),
-                   "dst.rows()", dst.rows());
-  check_size_match("copy (Eigen -> (OpenCL))", "src.cols()", src.cols(),
-                   "dst.cols()", dst.cols());
+inline matrix_cl to_matrix_cl(const Eigen::Matrix<double, R, C>& src) {
+  matrix_cl dst(src.rows(), src.cols());
   if (src.size() == 0) {
-    return;
+    return dst;
   }
   try {
     /**
@@ -61,28 +56,23 @@ void copy(matrix_cl& dst, const Eigen::Matrix<double, R, C>& src) {
   } catch (const cl::Error& e) {
     check_opencl_error("copy Eigen->(OpenCL)", e);
   }
+  return dst;
 }
 
 /**
  * Copies the source matrix that is stored
  * on the OpenCL device to the destination Eigen
  * matrix.
  *
- * @tparam T type of data in the Eigen matrix
- * @param dst destination Eigen matrix
  * @param src source matrix on the OpenCL device
- *
- * @throw <code>std::invalid_argument</code> if the
- * matrices do not have matching dimensions
+ * @return Eigen matrix with a copy of the data in the source matrix
  */
-template <int R, int C>
-void copy(Eigen::Matrix<double, R, C>& dst, const matrix_cl& src) {
-  check_size_match("copy ((OpenCL) -> Eigen)", "src.rows()", src.rows(),
-                   "dst.rows()", dst.rows());
-  check_size_match("copy ((OpenCL) -> Eigen)", "src.cols()", src.cols(),
-                   "dst.cols()", dst.cols());
+inline Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> from_matrix_cl(
+    const matrix_cl& src) {
+  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> dst(src.rows(),
+                                                            src.cols());
   if (src.size() == 0) {
-    return;
+    return dst;
   }
   try {
     /**
@@ -103,6 +93,7 @@ void copy(Eigen::Matrix<double, R, C>& dst, const matrix_cl& src) {
   } catch (const cl::Error& e) {
     check_opencl_error("copy (OpenCL)->Eigen", e);
   }
+  return dst;
 }
 
 /**
@@ -184,19 +175,15 @@ inline matrix_cl packed_copy(const std::vector<double>& src, int rows) {
  * destination matrix. Both matrices
  * are stored on the OpenCL device.
  *
- * @param dst destination matrix
  * @param src source matrix
- *
+ * @return matrix_cl with copies of values in the source matrix
  * @throw <code>std::invalid_argument</code> if the
  * matrices do not have matching dimensions
  */
-inline void copy(matrix_cl& dst, const matrix_cl& src) {
-  check_size_match("copy ((OpenCL) -> (OpenCL))", "src.rows()", src.rows(),
-                   "dst.rows()", dst.rows());
-  check_size_match("copy ((OpenCL) -> (OpenCL))", "src.cols()", src.cols(),
-                   "dst.cols()", dst.cols());
+inline matrix_cl copy_cl(const matrix_cl& src) {
+  matrix_cl dst(src.rows(), src.cols());
   if (src.size() == 0) {
-    return;
+    return dst;
   }
   try {
     /**
@@ -216,16 +203,18 @@ inline void copy(matrix_cl& dst, const matrix_cl& src) {
   } catch (const cl::Error& e) {
     check_opencl_error("copy (OpenCL)->(OpenCL)", e);
   }
+  return dst;
 }
 
 /**
  * Copy A 1 by 1 source matrix from the Device to  the host.
- * @tparam An arithmetic type to pass the value from the OpenCL matrix to.
- * @param dst Arithmetic to receive the matrix_cl value.
+ * @tparam T An arithmetic type to pass the value from the OpenCL matrix to.
  * @param src A 1x1 matrix on the device.
+ * @return dst Arithmetic to receive the matrix_cl value.
  */
 template <typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
-inline void copy(T& dst, const matrix_cl& src) {
+inline T from_matrix_cl(const matrix_cl& src) {
+  T dst;
   check_size_match("copy ((OpenCL) -> (OpenCL))", "src.rows()", src.rows(),
                    "dst.rows()", 1);
   check_size_match("copy ((OpenCL) -> (OpenCL))", "src.cols()", src.cols(),
@@ -240,16 +229,18 @@ inline void copy(T& dst, const matrix_cl& src) {
   } catch (const cl::Error& e) {
     check_opencl_error("copy (OpenCL)->(OpenCL)", e);
   }
+  return dst;
 }
 
 /**
  * Copy an arithmetic type to the device.
- * @tparam An arithmetic type to pass the value from the OpenCL matrix to.
+ * @tparam T An arithmetic type to pass the value from the OpenCL matrix to.
  * @param src Arithmetic to receive the matrix_cl value.
- * @param dst A 1x1 matrix on the device.
+ * @return A 1x1 matrix on the device.
  */
 template <typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
-inline void copy(matrix_cl& dst, const T& src) {
+inline matrix_cl to_matrix_cl(const T& src) {
+  matrix_cl dst(1, 1);
   check_size_match("copy ((OpenCL) -> (OpenCL))", "src.rows()", dst.rows(),
                    "dst.rows()", 1);
   check_size_match("copy ((OpenCL) -> (OpenCL))", "src.cols()", dst.cols(),
@@ -263,6 +254,7 @@ inline void copy(matrix_cl& dst, const T& src) {
   } catch (const cl::Error& e) {
     check_opencl_error("copy (OpenCL)->(OpenCL)", e);
   }
+  return dst;
 }
 
 }  // namespace math

stan/math/opencl/err/check_diagonal_zeros.hpp

@@ -29,10 +29,10 @@ inline void check_diagonal_zeros(const char* function, const char* name,
   try {
     int zero_on_diagonal_flag = 0;
     matrix_cl zeros_flag(1, 1);
-    copy(zeros_flag, zero_on_diagonal_flag);  // NOLINT
+    zeros_flag = to_matrix_cl(zero_on_diagonal_flag);
     opencl_kernels::check_diagonal_zeros(cl::NDRange(y.rows(), y.cols()), y,
                                          zeros_flag, y.rows(), y.cols());
-    copy(zero_on_diagonal_flag, zeros_flag);  // NOLINT
+    zero_on_diagonal_flag = from_matrix_cl<int>(zeros_flag);
     //  if zeros were found on the diagonal
     if (zero_on_diagonal_flag) {
       domain_error(function, name, "has zeros on the diagonal.", "");

stan/math/opencl/err/check_nan.hpp

@@ -28,10 +28,10 @@ inline void check_nan(const char* function, const char* name,
   try {
     int nan_flag = 0;
     matrix_cl nan_chk(1, 1);
-    copy(nan_chk, nan_flag);  // NOLINT
+    nan_chk = to_matrix_cl(nan_flag);
     opencl_kernels::check_nan(cl::NDRange(y.rows(), y.cols()), y, nan_chk,
                               y.rows(), y.cols());
-    copy(nan_flag, nan_chk);  // NOLINT
+    nan_flag = from_matrix_cl<int>(nan_chk);
     if (nan_flag) {
       domain_error(function, name, "has NaN values", "");
     }

stan/math/opencl/err/check_symmetric.hpp

@@ -29,11 +29,11 @@ inline void check_symmetric(const char* function, const char* name,
   try {
     int symmetric_flag = 1;
     matrix_cl symm_flag(1, 1);
-    copy(symm_flag, symmetric_flag);  // NOLINT
+    symm_flag = to_matrix_cl(symmetric_flag);
     opencl_kernels::check_symmetric(cl::NDRange(y.rows(), y.cols()), y,
                                     symm_flag, y.rows(), y.cols(),
                                     math::CONSTRAINT_TOLERANCE);
-    copy(symmetric_flag, symm_flag);  // NOLINT
+    symmetric_flag = from_matrix_cl<int>(symm_flag);
     if (!symmetric_flag) {
       domain_error(function, name, "is not symmetric", "");
     }

stan/math/prim/mat/fun/cholesky_decompose.hpp

@@ -69,7 +69,7 @@ inline Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> cholesky_decompose(
     cholesky_decompose(m_cl);
     check_nan("cholesky_decompose (OpenCL)", "Matrix m", m_cl);
     check_diagonal_zeros("cholesky_decompose (OpenCL)", "Matrix m", m_cl);
-    copy(m_chol, m_cl);  // NOLINT
+    m_chol = from_matrix_cl(m_cl);
     return m_chol;
   } else {
     check_symmetric("cholesky_decompose", "m", m);

test/unit/math/opencl/add_test.cpp

@@ -5,7 +5,7 @@
 #include <gtest/gtest.h>
 #include <algorithm>
 
-TEST(MathMatrixGPU, add_v_exception_pass) {
+TEST(MathMatrixCL, add_v_exception_pass) {
   stan::math::vector_d d1, d2;
 
   d1.resize(3);
@@ -16,7 +16,7 @@ TEST(MathMatrixGPU, add_v_exception_pass) {
   EXPECT_NO_THROW(d33 = d11 + d22);
 }
 
-TEST(MathMatrixGPU, add_v_exception_pass_zero) {
+TEST(MathMatrixCL, add_v_exception_pass_zero) {
   stan::math::vector_d d1, d2;
   d1.resize(0);
   d2.resize(0);
@@ -26,7 +26,7 @@ TEST(MathMatrixGPU, add_v_exception_pass_zero) {
   EXPECT_NO_THROW(d33 = d11 + d22);
 }
 
-TEST(MathMatrixGPU, add_v_exception_pass_invalid_arg) {
+TEST(MathMatrixCL, add_v_exception_pass_invalid_arg) {
   stan::math::row_vector_d d1, d2;
 
   d1.resize(2);
@@ -37,7 +37,7 @@ TEST(MathMatrixGPU, add_v_exception_pass_invalid_arg) {
   EXPECT_THROW(d33 = d11 + d22, std::invalid_argument);
 }
 
-TEST(MathMatrixGPU, add_rv_exception_pass) {
+TEST(MathMatrixCL, add_rv_exception_pass) {
   stan::math::row_vector_d d1, d2;
 
   d1.resize(3);
@@ -48,7 +48,7 @@ TEST(MathMatrixGPU, add_rv_exception_pass) {
   EXPECT_NO_THROW(d33 = d11 + d22);
 }
 
-TEST(MathMatrixGPU, add_rv_exception_pass_zero) {
+TEST(MathMatrixCL, add_rv_exception_pass_zero) {
   stan::math::row_vector_d d1, d2;
 
   d1.resize(0);
@@ -59,7 +59,7 @@ TEST(MathMatrixGPU, add_rv_exception_pass_zero) {
   EXPECT_NO_THROW(d33 = d11 + d22);
 }
 
-TEST(MathMatrixGPU, add_rv_exception_fail_invalid_arg) {
+TEST(MathMatrixCL, add_rv_exception_fail_invalid_arg) {
   stan::math::row_vector_d d1, d2;
 
   d1.resize(2);
@@ -70,7 +70,7 @@ TEST(MathMatrixGPU, add_rv_exception_fail_invalid_arg) {
   EXPECT_THROW(d33 = d11 + d22, std::invalid_argument);
 }
 
-TEST(MathMatrixGPU, add_m_exception_pass_simple) {
+TEST(MathMatrixCL, add_m_exception_pass_simple) {
   stan::math::matrix_d d1, d2;
 
   d1.resize(2, 3);
@@ -81,7 +81,7 @@ TEST(MathMatrixGPU, add_m_exception_pass_simple) {
   EXPECT_NO_THROW(d33 = d11 + d22);
 }
 
-TEST(MathMatrixGPU, add_m_exception_pass_zero) {
+TEST(MathMatrixCL, add_m_exception_pass_zero) {
   stan::math::matrix_d d1, d2;
   d1.resize(0, 0);
   d2.resize(0, 0);
@@ -91,7 +91,7 @@ TEST(MathMatrixGPU, add_m_exception_pass_zero) {
   EXPECT_NO_THROW(d33 = d11 + d22);
 }
 
-TEST(MathMatrixGPU, add_m_exception_fail_invalid_arg) {
+TEST(MathMatrixCL, add_m_exception_fail_invalid_arg) {
   stan::math::matrix_d d1, d2;
   d1.resize(2, 3);
   d2.resize(3, 3);
@@ -101,7 +101,7 @@ TEST(MathMatrixGPU, add_m_exception_fail_invalid_arg) {
   EXPECT_THROW(d33 = d11 + d22, std::invalid_argument);
 }
 
-TEST(MathMatrixGPU, add_non_matching_sizes_exception) {
+TEST(MathMatrixCL, add_non_matching_sizes_exception) {
   stan::math::vector_d v1(2);
   v1 << 1, 2;
   stan::math::vector_d v2(3);
@@ -134,7 +134,7 @@ TEST(MathMatrixGPU, add_non_matching_sizes_exception) {
   EXPECT_THROW(m33 = m11 + m22, std::invalid_argument);
 }
 
-TEST(MathMatrixGPU, add_value_check) {
+TEST(MathMatrixCL, add_value_check) {
   stan::math::vector_d v1(3);
   v1 << 1, 2, 3;
   stan::math::vector_d v2(3);
@@ -169,17 +169,17 @@ TEST(MathMatrixGPU, add_value_check) {
   EXPECT_NO_THROW(rv33 = rv11 + rv22);
   EXPECT_NO_THROW(m33 = m11 + m22);
 
-  stan::math::copy(v3, v33);
+  v3 = stan::math::from_matrix_cl(v33);
   EXPECT_EQ(11, v3(0));
   EXPECT_EQ(102, v3(1));
   EXPECT_EQ(1003, v3(2));
 
-  stan::math::copy(rv3, rv33);
+  rv3 = stan::math::from_matrix_cl(rv33);
   EXPECT_EQ(11, rv3(0));
   EXPECT_EQ(102, rv3(1));
   EXPECT_EQ(1003, rv3(2));
 
-  stan::math::copy(m3, m33);
+  m3 = stan::math::from_matrix_cl(m33);
   EXPECT_EQ(11, m3(0, 0));
   EXPECT_EQ(102, m3(0, 1));
   EXPECT_EQ(1003, m3(0, 2));
@@ -191,7 +191,7 @@ TEST(MathMatrixGPU, add_value_check) {
   EXPECT_EQ(17, m3(2, 2));
 }
 
-TEST(MathMatrixGPU, add_batch) {
+TEST(MathMatrixCL, add_batch) {
   // used to represent 5 matrices of size 10x10
   const int batch_size = 11;
   const int size = 13;
@@ -207,7 +207,7 @@ TEST(MathMatrixGPU, add_batch) {
   stan::math::matrix_cl a_cl_res(size, size);
   stan::math::opencl_kernels::add_batch(cl::NDRange(size, size), a_cl_res, a_cl,
                                         size, size, batch_size);
-  copy(a_res, a_cl_res);
+  a_res = stan::math::from_matrix_cl(a_cl_res);
   for (int k = 0; k < batch_size; k++) {
     for (int i = 0; i < size; i++)
       for (int j = 0; j < size; j++) {

test/unit/math/opencl/async_test.cpp

@@ -14,10 +14,10 @@ TEST(async_opencl, thrash_opencl) {
   stan::math::matrix_d m1 = stan::math::matrix_d::Random(size, size);
   stan::math::matrix_d m1_result = m1 + m1 * m1 - m1;
   stan::math::matrix_cl m1_cl(size, size);
-  stan::math::copy(m1_cl, m1);  // NOLINT
+  m1_cl = stan::math::to_matrix_cl(m1);
   stan::math::matrix_cl m1_result_cl = m1_cl + m1_cl * m1_cl - m1_cl;
   stan::math::matrix_d m1_result_test(size, size);
-  stan::math::copy(m1_result_test, m1_result_cl);  // NOLINT
+  m1_result_test = stan::math::from_matrix_cl(m1_result_cl);
   EXPECT_MATRIX_NEAR(m1_result, m1_result_test, 1e-12)
 }
 
@@ -28,11 +28,11 @@ TEST(async_opencl, assign_miss) {
   stan::math::matrix_d m1_result = m1 + m1 * m1 - m1;
   m1_result = m1_result + m1_result * m1_result - m1_result;
   stan::math::matrix_cl m1_cl(size, size);
-  stan::math::copy(m1_cl, m1);  // NOLINT
+  m1_cl = stan::math::to_matrix_cl(m1);
   stan::math::matrix_cl m1_result_cl = m1_cl + m1_cl * m1_cl - m1_cl;
   m1_result_cl = m1_result_cl + m1_result_cl * m1_result_cl - m1_result_cl;
   stan::math::matrix_d m1_result_test(size, size);
-  stan::math::copy(m1_result_test, m1_result_cl);  // NOLINT
+  m1_result_test = stan::math::from_matrix_cl(m1_result_cl);
   EXPECT_MATRIX_NEAR(m1_result, m1_result_test, 1e-12)
 }
 
@@ -42,15 +42,15 @@ TEST(async_opencl, read_miss) {
   stan::math::matrix_d m1 = stan::math::matrix_d::Random(size, size);
   stan::math::matrix_d m1_result = m1 + m1 * m1 - m1;
   stan::math::matrix_cl m1_cl(size, size);
-  stan::math::copy(m1_cl, m1);  // NOLINT
+  m1_cl = stan::math::to_matrix_cl(m1);
   stan::math::matrix_cl m1_result_cl = m1_cl + m1_cl * m1_cl - m1_cl;
   m1_cl = m1_cl * 2;
   stan::math::matrix_d m1_result_test(size, size);
-  stan::math::copy(m1_result_test, m1_result_cl);  // NOLINT
+  m1_result_test = stan::math::from_matrix_cl(m1_result_cl);
   EXPECT_MATRIX_NEAR(m1_result, m1_result_test, 1e-12)
   m1 = m1 * 2;
   stan::math::matrix_d m1_multiply_test(size, size);
-  stan::math::copy(m1_multiply_test, m1_cl);  // NOLINT
+  m1_multiply_test = stan::math::from_matrix_cl(m1_cl);
   EXPECT_MATRIX_NEAR(m1, m1_multiply_test, 1e-12)
 }
 

test/unit/math/opencl/check_test.cpp

@@ -53,7 +53,7 @@ TEST(ErrorHandlingScalarGPU, check_nan_positions) {
   EXPECT_THROW(check_nan(function, "xx_mat3", xx_mat3), std::domain_error);
 }
 
-TEST(ErrorHandlingScalarGPU, check_rv_v_symmetric_gpu) {
+TEST(ErrorHandlingScalarGPU, check_rv_v_symmetric_cl) {
   const char* function = "check_symmetric";
 
   stan::math::row_vector_d rv;