Feature/1854 OpenCL /prim signatures part 1 (#1859)

* added dims

* finished add, rows, cols

* scalar + matrix

* simplify with tadej's suggestion

* add col and tests and add the block boundary checks

* add row and row tests

* inv_sqrt done

* inv_square

* inv logit

* add inv_cloglog

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

* add inv()

* [Jenkins] auto-formatting by clang-format version 6.0.0

* fix doxygen, cpplint

* add header guards

* revising the block checks, cpplint

* [Jenkins] auto-formatting by clang-format version 6.0.0

* missing ifdef

* newline

* fix comments and use of x instead of a

* expression is now kernel_expression

* fix row/col

* fix comments, change throw behaviour of block

* fix block test

* add row/col tests with expressions

* [Jenkins] auto-formatting by clang-format version 6.0.0

* rename require

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

* rename require

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

* fix tests

* add forward

* is_valid_kernel_expression to is_kernel_expression

* fix inv_square and inv_logit

* cleanup after merge

* replace with EXPECT_MATRIX_NEAR

* [Jenkins] auto-formatting by clang-format version 6.0.0

* remove duplicate include

* Update stan/math/opencl/prim/cols.hpp

Co-authored-by: Tadej Ciglarič <tadej.c@gmail.com>

* Update stan/math/opencl/prim/dims.hpp

Co-authored-by: Tadej Ciglarič <tadej.c@gmail.com>

* Update stan/math/opencl/prim/rows.hpp

Co-authored-by: Tadej Ciglarič <tadej.c@gmail.com>

* removed comment

* fix rows/cols template

Co-authored-by: Stan Jenkins <mc.stanislaw@gmail.com>
Co-authored-by: Jenkins <nobody@nowhere>
Co-authored-by: Tadej Ciglarič <tadej.c@gmail.com>

Author: 4 people

stan/math/opencl/kernel_generator.hpp

@@ -109,7 +109,7 @@
 #include <stan/math/opencl/kernel_generator/operation_cl.hpp>
 #include <stan/math/opencl/kernel_generator/operation_cl_lhs.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <stan/math/opencl/kernel_generator/name_generator.hpp>
 #include <stan/math/opencl/kernel_generator/type_str.hpp>
 

stan/math/opencl/kernel_generator/append.hpp

@@ -10,7 +10,7 @@
 #include <stan/math/opencl/kernel_generator/operation_cl.hpp>
 #include <stan/math/opencl/kernel_generator/scalar.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <stan/math/opencl/kernel_generator/common_return_scalar.hpp>
 #include <algorithm>
 #include <string>
@@ -162,7 +162,7 @@ class append_row_ : public operation_cl<append_row_<T_a, T_b>,
  * @return Stacked arguments
  */
 template <typename Ta, typename Tb,
-          typename = require_all_valid_expressions_and_none_scalar_t<Ta, Tb>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<Ta, Tb>>
 inline auto append_row(Ta&& a, Tb&& b) {
   auto&& a_operation = as_operation_cl(std::forward<Ta>(a)).deep_copy();
   auto&& b_operation = as_operation_cl(std::forward<Tb>(b)).deep_copy();
@@ -307,7 +307,7 @@ class append_col_ : public operation_cl<append_col_<T_a, T_b>,
  * @return Stacked arguments
  */
 template <typename Ta, typename Tb,
-          typename = require_all_valid_expressions_and_none_scalar_t<Ta, Tb>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<Ta, Tb>>
 inline auto append_col(Ta&& a, Tb&& b) {
   auto&& a_operation = as_operation_cl(std::forward<Ta>(a)).deep_copy();
   auto&& b_operation = as_operation_cl(std::forward<Tb>(b)).deep_copy();

stan/math/opencl/kernel_generator/binary_operation.hpp

@@ -10,7 +10,7 @@
 #include <stan/math/opencl/kernel_generator/operation_cl.hpp>
 #include <stan/math/opencl/kernel_generator/scalar.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <stan/math/opencl/kernel_generator/common_return_scalar.hpp>
 #include <algorithm>
 #include <string>
@@ -126,7 +126,7 @@ class binary_operation : public operation_cl<Derived, T_res, T_a, T_b> {
   };                                                                          \
                                                                               \
   template <typename T_a, typename T_b,                                       \
-            typename = require_all_valid_expressions_t<T_a, T_b>>             \
+            typename = require_all_kernel_expressions_t<T_a, T_b>>            \
   inline class_name<as_operation_cl_t<T_a>, as_operation_cl_t<T_b>>           \
   function_name(T_a&& a, T_b&& b) { /* NOLINT */                              \
     return {as_operation_cl(std::forward<T_a>(a)),                            \
@@ -176,7 +176,7 @@ class binary_operation : public operation_cl<Derived, T_res, T_a, T_b> {
   };                                                                          \
                                                                               \
   template <typename T_a, typename T_b,                                       \
-            typename = require_all_valid_expressions_t<T_a, T_b>>             \
+            typename = require_all_kernel_expressions_t<T_a, T_b>>            \
   inline class_name<as_operation_cl_t<T_a>, as_operation_cl_t<T_b>>           \
   function_name(T_a&& a, T_b&& b) { /* NOLINT */                              \
     return {as_operation_cl(std::forward<T_a>(a)),                            \
@@ -245,7 +245,7 @@ ADD_BINARY_OPERATION_WITH_CUSTOM_CODE(
  * @return Multiplication of given arguments
  */
 template <typename T_a, typename T_b, typename = require_arithmetic_t<T_a>,
-          typename = require_all_valid_expressions_t<T_b>>
+          typename = require_all_kernel_expressions_t<T_b>>
 inline elewise_multiplication_<scalar_<T_a>, as_operation_cl_t<T_b>> operator*(
     T_a&& a, T_b&& b) {  // NOLINT
   return {as_operation_cl(std::forward<T_a>(a)),
@@ -261,7 +261,7 @@ inline elewise_multiplication_<scalar_<T_a>, as_operation_cl_t<T_b>> operator*(
  * @return Multiplication of given arguments
  */
 template <typename T_a, typename T_b,
-          typename = require_all_valid_expressions_t<T_a>,
+          typename = require_all_kernel_expressions_t<T_a>,
           typename = require_arithmetic_t<T_b>>
 inline elewise_multiplication_<as_operation_cl_t<T_a>, scalar_<T_b>> operator*(
     T_a&& a, const T_b b) {  // NOLINT

stan/math/opencl/kernel_generator/block.hpp

@@ -9,7 +9,7 @@
 #include <stan/math/opencl/kernel_generator/name_generator.hpp>
 #include <stan/math/opencl/kernel_generator/operation_cl_lhs.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <set>
 #include <string>
 #include <tuple>
@@ -57,9 +57,25 @@ class block_
         start_col_(start_col),
         rows_(rows),
         cols_(cols) {
+    if (start_col < 0) {
+      invalid_argument("block", "start_col", start_col,
+                       " should be non-negative, but is ");
+    }
+    if (start_row < 0) {
+      invalid_argument("block", "start_row", start_row,
+                       " should be non-negative, but is ");
+    }
+    if (rows < 0) {
+      invalid_argument("block", "rows", rows,
+                       " should be non-negative, but is ");
+    }
+    if (cols < 0) {
+      invalid_argument("block", "cols", cols,
+                       " should be non-negative, but is ");
+    }
     if ((a.rows() != base::dynamic && (start_row + rows) > a.rows())
         || (a.cols() != base::dynamic && (start_col + cols) > a.cols())) {
-      throw_domain_error("block", "block of \"a\"", " is out of bounds", "");
+      invalid_argument("block", "block of \"a\"", " is out of bounds", "");
     }
   }
 
@@ -216,7 +232,7 @@ class block_
  * @return Block of given expression
  */
 template <typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline auto block(T&& a, int start_row, int start_col, int rows, int cols) {
   auto&& a_operation = as_operation_cl(std::forward<T>(a)).deep_copy();
   return block_<std::remove_reference_t<decltype(a_operation)>>(

stan/math/opencl/kernel_generator/broadcast.hpp

@@ -8,7 +8,7 @@
 #include <stan/math/opencl/kernel_generator/name_generator.hpp>
 #include <stan/math/opencl/kernel_generator/operation_cl.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <limits>
 #include <string>
 #include <type_traits>
@@ -138,7 +138,7 @@ class broadcast_
  * @return broadcast expression
  */
 template <bool Colwise, bool Rowwise, typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline broadcast_<as_operation_cl_t<T>, Colwise, Rowwise> broadcast(T&& a) {
   auto&& a_operation = as_operation_cl(std::forward<T>(a)).deep_copy();
   return broadcast_<as_operation_cl_t<T>, Colwise, Rowwise>(
@@ -158,7 +158,7 @@ inline broadcast_<as_operation_cl_t<T>, Colwise, Rowwise> broadcast(T&& a) {
  * @return broadcast expression
  */
 template <typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline auto rowwise_broadcast(T&& a) {
   return broadcast<false, true>(std::forward<T>(a));
 }
@@ -176,7 +176,7 @@ inline auto rowwise_broadcast(T&& a) {
  * @return broadcast expression
  */
 template <typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline auto colwise_broadcast(T&& a) {
   return broadcast<true, false>(std::forward<T>(a));
 }

stan/math/opencl/kernel_generator/calc_if.hpp

@@ -8,7 +8,7 @@
 #include <stan/math/opencl/kernel_generator/name_generator.hpp>
 #include <stan/math/opencl/kernel_generator/operation_cl.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <string>
 #include <type_traits>
 #include <set>
@@ -91,7 +91,7 @@ class calc_if_
 };
 
 template <bool Do_Calculate, typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline calc_if_<Do_Calculate, as_operation_cl_t<T>> calc_if(T&& a) {
   return calc_if_<Do_Calculate, as_operation_cl_t<T>>(
       as_operation_cl(std::forward<T>(a)));

stan/math/opencl/kernel_generator/colwise_reduction.hpp

@@ -9,7 +9,7 @@
 #include <stan/math/opencl/kernel_generator/name_generator.hpp>
 #include <stan/math/opencl/kernel_generator/operation_cl.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <stan/math/opencl/kernel_generator/rowwise_reduction.hpp>
 #include <set>
 #include <string>
@@ -181,7 +181,7 @@ class colwise_sum_ : public colwise_reduction<colwise_sum_<T>, T, sum_op> {
  * @return sum
  */
 template <typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline auto colwise_sum(T&& a) {
   auto&& arg_copy = as_operation_cl(std::forward<T>(a)).deep_copy();
   return colwise_sum_<std::remove_reference_t<decltype(arg_copy)>>(
@@ -229,7 +229,7 @@ class colwise_max_ : public colwise_reduction<
  * @return max
  */
 template <typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline auto colwise_max(T&& a) {
   auto&& arg_copy = as_operation_cl(std::forward<T>(a)).deep_copy();
   return colwise_max_<std::remove_reference_t<decltype(arg_copy)>>(
@@ -277,7 +277,7 @@ class colwise_min_ : public colwise_reduction<
  * @return min
  */
 template <typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline auto colwise_min(T&& a) {
   auto&& arg_copy = as_operation_cl(std::forward<T>(a)).deep_copy();
   return colwise_min_<std::remove_reference_t<decltype(arg_copy)>>(

stan/math/opencl/kernel_generator/diagonal.hpp

@@ -8,7 +8,7 @@
 #include <stan/math/opencl/kernel_generator/name_generator.hpp>
 #include <stan/math/opencl/kernel_generator/operation_cl_lhs.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <algorithm>
 #include <set>
 #include <string>
@@ -166,7 +166,7 @@ class diagonal_
  * @return Diagonal of given expression
  */
 template <typename T,
-          typename = require_all_valid_expressions_and_none_scalar_t<T>>
+          typename = require_all_kernel_expressions_and_none_scalar_t<T>>
 inline auto diagonal(T&& a) {
   auto&& a_operation = as_operation_cl(std::forward<T>(a)).deep_copy();
   return diagonal_<std::remove_reference_t<decltype(a_operation)>>(

stan/math/opencl/kernel_generator/evaluate_into.hpp

@@ -5,7 +5,7 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/opencl/kernel_generator/operation_cl.hpp>
 #include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
-#include <stan/math/opencl/kernel_generator/is_valid_expression.hpp>
+#include <stan/math/opencl/kernel_generator/is_kernel_expression.hpp>
 #include <stan/math/opencl/kernel_generator/multi_result_kernel.hpp>
 #include <CL/cl2.hpp>
 #include <string>
@@ -21,7 +21,7 @@ template <typename Derived, typename Scalar, typename... Args>
 template <typename T_lhs>
 void operation_cl<Derived, Scalar, Args...>::evaluate_into(T_lhs& lhs) const {
   static_assert(
-      is_valid_expression<T_lhs>::value,
+      is_kernel_expression<T_lhs>::value,
       "operation_cl::evaluate_into: left hand side is not a valid expression!");
   results(lhs) = expressions(derived());
 }

stan/math/opencl/kernel_generator/get_kernel_source_for_evaluating_into.hpp

@@ -21,7 +21,7 @@ std::string
 operation_cl<Derived, Scalar, Args...>::get_kernel_source_for_evaluating_into(
     const T_lhs& lhs) const {
   static_assert(
-      is_valid_expression<T_lhs>::value,
+      is_kernel_expression<T_lhs>::value,
       "operation_cl::get_kernel_source_for_evaluating_into: left hand "
       "side is not a valid expression!");
   return results(lhs).get_kernel_source_for_evaluating(expressions(derived()));