Ginkgo  Generated from pipelines/2017069469 branch based on develop. Ginkgo version 1.11.0
A numerical linear algebra library targeting many-core architectures
diagonal.hpp
1 // SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
2 //
3 // SPDX-License-Identifier: BSD-3-Clause
4 
5 #ifndef GKO_PUBLIC_CORE_MATRIX_DIAGONAL_HPP_
6 #define GKO_PUBLIC_CORE_MATRIX_DIAGONAL_HPP_
7 
8 
9 #include <ginkgo/core/base/array.hpp>
10 #include <ginkgo/core/base/lin_op.hpp>
11 
12 
13 namespace gko {
14 namespace matrix {
15 
16 
17 template <typename ValueType, typename IndexType>
18 class Csr;
19 
20 template <typename ValueType>
21 class Dense;
22 
23 
39 template <typename ValueType = default_precision>
40 class Diagonal
41  : public EnableLinOp<Diagonal<ValueType>>,
42  public ConvertibleTo<Csr<ValueType, int32>>,
43  public ConvertibleTo<Csr<ValueType, int64>>,
44  public ConvertibleTo<Diagonal<next_precision<ValueType>>>,
45 #if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16
46  public ConvertibleTo<Diagonal<next_precision<ValueType, 2>>>,
47 #endif
48 #if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16
49  public ConvertibleTo<Diagonal<next_precision<ValueType, 3>>>,
50 #endif
51  public Transposable,
52  public WritableToMatrixData<ValueType, int32>,
53  public WritableToMatrixData<ValueType, int64>,
54  public ReadableFromMatrixData<ValueType, int32>,
55  public ReadableFromMatrixData<ValueType, int64>,
56  public EnableAbsoluteComputation<remove_complex<Diagonal<ValueType>>> {
57  friend class EnablePolymorphicObject<Diagonal, LinOp>;
58  friend class Csr<ValueType, int32>;
59  friend class Csr<ValueType, int64>;
60  friend class Diagonal<to_complex<ValueType>>;
61 
62 public:
65  using ConvertibleTo<Csr<ValueType, int32>>::convert_to;
66  using ConvertibleTo<Csr<ValueType, int32>>::move_to;
67  using ConvertibleTo<Csr<ValueType, int64>>::convert_to;
68  using ConvertibleTo<Csr<ValueType, int64>>::move_to;
69  using ConvertibleTo<Diagonal<next_precision<ValueType>>>::convert_to;
70  using ConvertibleTo<Diagonal<next_precision<ValueType>>>::move_to;
71 
72  using value_type = ValueType;
73  using index_type = int64;
74  using mat_data = matrix_data<ValueType, int64>;
75  using mat_data32 = matrix_data<ValueType, int32>;
76  using device_mat_data = device_matrix_data<ValueType, int64>;
77  using device_mat_data32 = device_matrix_data<ValueType, int32>;
78  using absolute_type = remove_complex<Diagonal>;
79 
80  friend class Diagonal<previous_precision<ValueType>>;
81 
82  std::unique_ptr<LinOp> transpose() const override;
83 
84  std::unique_ptr<LinOp> conj_transpose() const override;
85 
86  void convert_to(Diagonal<next_precision<ValueType>>* result) const override;
87 
88  void move_to(Diagonal<next_precision<ValueType>>* result) override;
89 
90 #if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16
91  friend class Diagonal<previous_precision<ValueType, 2>>;
92  using ConvertibleTo<Diagonal<next_precision<ValueType, 2>>>::convert_to;
93  using ConvertibleTo<Diagonal<next_precision<ValueType, 2>>>::move_to;
94 
95  void convert_to(
96  Diagonal<next_precision<ValueType, 2>>* result) const override;
97 
98  void move_to(Diagonal<next_precision<ValueType, 2>>* result) override;
99 #endif
100 
101 #if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16
102  friend class Diagonal<previous_precision<ValueType, 3>>;
103  using ConvertibleTo<Diagonal<next_precision<ValueType, 3>>>::convert_to;
104  using ConvertibleTo<Diagonal<next_precision<ValueType, 3>>>::move_to;
105 
106  void convert_to(
107  Diagonal<next_precision<ValueType, 3>>* result) const override;
108 
109  void move_to(Diagonal<next_precision<ValueType, 3>>* result) override;
110 #endif
111 
112  void convert_to(Csr<ValueType, int32>* result) const override;
113 
114  void move_to(Csr<ValueType, int32>* result) override;
115 
116  void convert_to(Csr<ValueType, int64>* result) const override;
117 
118  void move_to(Csr<ValueType, int64>* result) override;
119 
120  std::unique_ptr<absolute_type> compute_absolute() const override;
121 
122  void compute_absolute_inplace() override;
123 
129  value_type* get_values() noexcept { return values_.get_data(); }
130 
138  const value_type* get_const_values() const noexcept
139  {
140  return values_.get_const_data();
141  }
142 
151  {
152  GKO_ASSERT_REVERSE_CONFORMANT(this, b);
153  GKO_ASSERT_EQUAL_ROWS(b, x);
154  GKO_ASSERT_EQUAL_COLS(this, x);
155 
156  this->rapply_impl(b.get(), x.get());
157  }
158 
169  {
170  GKO_ASSERT_CONFORMANT(this, b);
171  GKO_ASSERT_EQUAL_ROWS(b, x);
172  GKO_ASSERT_EQUAL_ROWS(this, x);
173 
174  this->inverse_apply_impl(b.get(), x.get());
175  }
176 
177  void read(const mat_data& data) override;
178 
179  void read(const mat_data32& data) override;
180 
181  void read(const device_mat_data& data) override;
182 
183  void read(const device_mat_data32& data) override;
184 
185  void read(device_mat_data&& data) override;
186 
187  void read(device_mat_data32&& data) override;
188 
189  void write(mat_data& data) const override;
190 
191  void write(mat_data32& data) const override;
192 
201  static std::unique_ptr<Diagonal> create(
202  std::shared_ptr<const Executor> exec, size_type size = 0);
203 
218  static std::unique_ptr<Diagonal> create(
219  std::shared_ptr<const Executor> exec, const size_type size,
220  array<value_type> values);
221 
226  template <typename InputValueType>
227  GKO_DEPRECATED(
228  "explicitly construct the gko::array argument instead of passing an"
229  "initializer list")
230  static std::unique_ptr<Diagonal> create(
231  std::shared_ptr<const Executor> exec, const size_type size,
232  std::initializer_list<InputValueType> values)
233  {
234  return create(exec, size, array<value_type>{exec, std::move(values)});
235  }
236 
247  static std::unique_ptr<const Diagonal> create_const(
248  std::shared_ptr<const Executor> exec, size_type size,
249  gko::detail::const_array_view<ValueType>&& values);
250 
251 protected:
252  Diagonal(std::shared_ptr<const Executor> exec, size_type size = 0);
253 
254  Diagonal(std::shared_ptr<const Executor> exec, const size_type size,
255  array<value_type> values);
256 
257  void apply_impl(const LinOp* b, LinOp* x) const override;
258 
259  void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
260  LinOp* x) const override;
261 
262  void rapply_impl(const LinOp* b, LinOp* x) const;
263 
264  void inverse_apply_impl(const LinOp* b, LinOp* x) const;
265 
266 private:
267  array<value_type> values_;
268 };
269 
270 
271 } // namespace matrix
272 } // namespace gko
273 
274 
275 #endif // GKO_PUBLIC_CORE_MATRIX_DIAGONAL_HPP_
gko::matrix::Diagonal::compute_absolute_inplace
void compute_absolute_inplace() override
Compute absolute inplace on each element.
gko::EnablePolymorphicAssignment< ConcreteLinOp >::move_to
void move_to(result_type *result) override
Definition: polymorphic_object.hpp:751
gko::EnablePolymorphicAssignment< ConcreteLinOp >::convert_to
void convert_to(result_type *result) const override
Definition: polymorphic_object.hpp:749
gko::LinOp
Definition: lin_op.hpp:117
gko::size_type
std::size_t size_type
Integral type used for allocation quantities.
Definition: types.hpp:90
gko::matrix::Diagonal::transpose
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
gko::ptr_param::get
T * get() const
Definition: utils_helper.hpp:75
gko::matrix::Diagonal::create_const
static std::unique_ptr< const Diagonal > create_const(std::shared_ptr< const Executor > exec, size_type size, gko::detail::const_array_view< ValueType > &&values)
Creates a constant (immutable) Diagonal matrix from a constant array.
gko
The Ginkgo namespace.
Definition: abstract_factory.hpp:20
gko::array< value_type >
gko::matrix::Diagonal::create
static std::unique_ptr< Diagonal > create(std::shared_ptr< const Executor > exec, size_type size=0)
Creates an Diagonal matrix of the specified size.
gko::matrix::Diagonal::compute_absolute
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.
gko::matrix::Diagonal
This class is a utility which efficiently implements the diagonal matrix (a linear operator which sca...
Definition: lin_op.hpp:31
gko::ptr_param
This class is used for function parameters in the place of raw pointers.
Definition: utils_helper.hpp:41
gko::array::get_data
value_type * get_data() noexcept
Returns a pointer to the block of memory used to store the elements of the array.
Definition: array.hpp:687
gko::matrix::Diagonal::rapply
void rapply(ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Applies the diagonal matrix from the right side to a matrix b, which means scales the columns of b wi...
Definition: diagonal.hpp:150
gko::previous_precision
typename detail::find_precision_impl< T, -step >::type previous_precision
Obtains the previous move type of T in the singly-linked precision corresponding bfloat16/half.
Definition: math.hpp:473
gko::int64
std::int64_t int64
64-bit signed integral type.
Definition: types.hpp:113
gko::int32
std::int32_t int32
32-bit signed integral type.
Definition: types.hpp:107
gko::Executor
The first step in using the Ginkgo library consists of creating an executor.
Definition: executor.hpp:615
gko::array::get_const_data
const value_type * get_const_data() const noexcept
Returns a constant pointer to the block of memory used to store the elements of the array.
Definition: array.hpp:696
gko::matrix::Diagonal::get_values
value_type * get_values() noexcept
Returns a pointer to the array of values of the matrix.
Definition: diagonal.hpp:129
gko::matrix::Diagonal::inverse_apply
void inverse_apply(ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Applies the inverse of the diagonal matrix to a matrix b, which means scales the columns of b with th...
Definition: diagonal.hpp:168
gko::matrix::Diagonal::conj_transpose
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
gko::matrix::Diagonal::get_const_values
const value_type * get_const_values() const noexcept
Returns a pointer to the array of values of the matrix.
Definition: diagonal.hpp:138
gko::LinOp::LinOp
LinOp(const LinOp &)=default
Copy-constructs a LinOp.
gko::to_complex
typename detail::to_complex_s< T >::type to_complex
Obtain the type which adds the complex of complex/scalar type or the template parameter of class by a...
Definition: math.hpp:283