constant.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_OPENCL_KERNEL_GENERATOR_CONSTANT_HPP
#define STAN_MATH_OPENCL_KERNEL_GENERATOR_CONSTANT_HPP
#ifdef STAN_OPENCL
 
#include <stan/math/opencl/matrix_cl.hpp>
#include <stan/math/opencl/matrix_cl_view.hpp>
#include <stan/math/opencl/kernel_generator/type_str.hpp>
#include <stan/math/opencl/kernel_generator/name_generator.hpp>
#include <stan/math/opencl/kernel_generator/operation_cl.hpp>
#include <limits>
#include <map>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace stan {
namespace math {
 
template <typename T>
class constant_ : public operation_cl<constant_<T>, T> {
  T a_;
  int rows_;
  int cols_;
 
 public:
  static_assert(std::is_arithmetic<T>::value,
                "class constant_<T>: std::is_arithmetic<T> must be true!");
  using Scalar = T;
  using base = operation_cl<constant_<T>, T>;
  using base::var_name_;
 
  explicit constant_(const T a, int rows, int cols)
      : a_(a), rows_(rows), cols_(cols) {}
 
  inline constant_<T> deep_copy() const {
    return constant_<T>(a_, rows_, cols_);
  }
 
  inline kernel_parts generate(const std::string& row_index_name,
                               const std::string& col_index_name,
                               const bool view_handled) const {
    kernel_parts res{};
    res.args = type_str<Scalar>() + " " + var_name_ + ", ";
    return res;
  }
 
  inline void set_args(
      std::unordered_map<const void*, const char*>& generated,
      std::unordered_map<const void*, const char*>& generated_all,
      cl::Kernel& kernel, int& arg_num) const {
    if (generated.count(this) == 0) {
      generated[this] = "";
      kernel.setArg(arg_num++, a_);
    }
  }
 
  inline int rows() const { return rows_; }
 
  inline int cols() const { return cols_; }
 
  inline std::pair<int, int> extreme_diagonals() const {
    return {std::numeric_limits<int>::min(), std::numeric_limits<int>::max()};
  }
};
 
template <typename T, typename = require_arithmetic_t<T>>
inline auto constant(const T a, int rows, int cols) {
  return constant_<T>(a, rows, cols);
}
 
}  // namespace math
}  // namespace stan
 
#endif
#endif