scalar.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_OPENCL_KERNEL_GENERATOR_SCALAR_HPP
#define STAN_MATH_OPENCL_KERNEL_GENERATOR_SCALAR_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 scalar_ : public operation_cl<scalar_<T>, T> {
 public:
  static_assert(std::is_arithmetic<T>::value,
                "class scalar_<T>: std::is_arithmetic<T> must be true!");
  using Scalar = T;
  using base = operation_cl<scalar_<T>, T>;
  using base::var_name_;
  T a_;
 
  explicit scalar_(const T a) : a_(a) {}
 
  inline scalar_<T> deep_copy() const { return scalar_<T>(a_); }
 
  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 base::dynamic; }
 
  inline int cols() const { return base::dynamic; }
 
  inline std::pair<int, int> extreme_diagonals() const {
    return {std::numeric_limits<int>::min(), std::numeric_limits<int>::max()};
  }
};
}  // namespace math
}  // namespace stan
 
#endif
#endif