ADD_BINARY_OPERATION

#define ADD_BINARY_OPERATION	(		class_name,
			function_name,
			scalar_type_expr,
			operation
	)

Value:

  template <typename T_a, typename T_b>                                       \
  class class_name : public binary_operation<class_name<T_a, T_b>,            \
                                             scalar_type_expr, T_a, T_b> {    \
    using base                                                                \
        = binary_operation<class_name<T_a, T_b>, scalar_type_expr, T_a, T_b>; \
    using base::arguments_;                                                   \
                                                                              \
   public:                                                                    \
    using base::rows;                                                         \
    using base::cols;                                                         \
    class_name(T_a&& a, T_b&& b) /* NOLINT */                                 \
        : base(std::forward<T_a>(a), std::forward<T_b>(b), operation) {}      \
    inline auto deep_copy() const {                                           \
      auto&& a_copy = this->template get_arg<0>().deep_copy();                \
      auto&& b_copy = this->template get_arg<1>().deep_copy();                \
      return class_name<std::remove_reference_t<decltype(a_copy)>,            \
                        std::remove_reference_t<decltype(b_copy)>>(           \
          std::move(a_copy), std::move(b_copy));                              \
    }                                                                         \
  };                                                                          \
                                                                              \
  template <typename T_a, typename T_b,                                       \
            require_all_kernel_expressions_t<T_a, T_b>* = nullptr,            \
            require_any_not_arithmetic_t<T_a, T_b>* = nullptr>                \
  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)),                            \
            as_operation_cl(std::forward<T_b>(b))};                           \
  }

Defines a new binary operation in kernel generator.

Parameters

class_name	The name of the class this macro will define to represent this operation
function_name	The name of the function this macro will define that will be used to create this operation.
scalar_type_expr	The type of the scalar in the result of this operation. Can be a C++ expression that uses T_a and T_b as types of the scalars in the arguments to this operation.
operation	String containing operator that is used to implement this operation in kernel. Should be a valid infix operator in OpenCL C.

Definition at line 104 of file binary_operation.hpp.