cast.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_OPENCL_KERNEL_GENERATOR_CAST_HPP
#define STAN_MATH_OPENCL_KERNEL_GENERATOR_CAST_HPP
#ifdef STAN_OPENCL
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/opencl/matrix_cl_view.hpp>
#include <stan/math/opencl/kernel_generator/common_return_scalar.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 <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
#include <array>
#include <string>
#include <type_traits>
#include <set>
#include <utility>
 
namespace stan {
namespace math {
 
template <typename Scal, typename T>
class cast_ : public operation_cl<cast_<Scal, T>, Scal, T> {
 public:
  using Scalar = Scal;
  using base = operation_cl<cast_<Scal, T>, Scalar, T>;
  using base::var_name_;
 
  explicit cast_(T&& arg) : base(std::forward<T>(arg)) {}
 
  inline kernel_parts generate(const std::string& row_index_name,
                               const std::string& col_index_name,
                               const bool view_handled,
                               const std::string& var_name_arg) const {
    kernel_parts res{};
 
    res.body = type_str<Scalar>() + " " + var_name_ + " = ("
               + type_str<Scalar>() + ")" + var_name_arg + ";\n";
    return res;
  }
 
  inline auto deep_copy() const {
    auto&& arg_copy = this->template get_arg<0>().deep_copy();
    return cast_<Scalar, std::remove_reference_t<decltype(arg_copy)>>{
        std::move(arg_copy)};
  }
};
 
template <typename Scalar, typename T,
          require_all_kernel_expressions_and_none_scalar_t<T>* = nullptr>
inline auto cast(T&& a) {
  auto&& a_operation = as_operation_cl(std::forward<T>(a)).deep_copy();
  return cast_<Scalar, std::remove_reference_t<decltype(a_operation)>>(
      std::move(a_operation));
}
 
template <typename Scalar, typename T, require_stan_scalar_t<T>* = nullptr>
inline Scalar cast(T a) {
  return a;
}
 
}  // namespace math
}  // namespace stan
#endif
#endif