diagonal.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_OPENCL_KERNEL_GENERATOR_DIAGONAL_HPP
#define STAN_MATH_OPENCL_KERNEL_GENERATOR_DIAGONAL_HPP
#ifdef STAN_OPENCL
 
#include <stan/math/prim/meta.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_lhs.hpp>
#include <stan/math/opencl/kernel_generator/as_operation_cl.hpp>
#include <algorithm>
#include <map>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace stan {
namespace math {
 
template <typename T>
class diagonal_
    : public operation_cl_lhs<diagonal_<T>,
                              typename std::remove_reference_t<T>::Scalar, T> {
 public:
  using Scalar = typename std::remove_reference_t<T>::Scalar;
  using base = operation_cl_lhs<diagonal_<T>, Scalar, T>;
  using base::var_name_;
  using base::operator=;
 
  explicit diagonal_(T&& a) : base(std::forward<T>(a)) {}
 
  inline auto deep_copy() const {
    auto&& arg_copy = this->template get_arg<0>().deep_copy();
    return diagonal_<std::remove_reference_t<decltype(arg_copy)>>{
        std::move(arg_copy)};
  }
 
  inline void modify_argument_indices(std::string& row_index_name,
                                      std::string& col_index_name) const {
    col_index_name = row_index_name;
  }
 
  inline int rows() const {
    return std::min(this->template get_arg<0>().rows(),
                    this->template get_arg<0>().cols());
  }
 
  inline int cols() const { return 1; }
 
  inline void set_view(int bottom_diagonal, int top_diagonal,
                       int bottom_zero_diagonal, int top_zero_diagonal) const {}
 
  inline std::pair<int, int> extreme_diagonals() const {
    return {1 - rows(), 1};
  }
 
  inline void check_assign_dimensions(int rows, int cols) const {
    check_size_match("diagonal_.check_assign_dimensions", "Rows of ",
                     "diagonal", this->rows(), "rows of ", "expression", rows);
    check_size_match("diagonal_.check_assign_dimensions", "Columns of ",
                     "diagonal", 1, "columns of ", "expression", cols);
  }
};
 
template <typename 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)>>(
      std::move(a_operation));
}
}  // namespace math
}  // namespace stan
 
#endif
#endif