Ginkgo Generated from branch based on main. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
Loading...
Searching...
No Matches
identity.hpp
1// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_MATRIX_IDENTITY_HPP_
6#define GKO_PUBLIC_CORE_MATRIX_IDENTITY_HPP_
7
8
9#include <ginkgo/core/base/lin_op.hpp>
10
11
12namespace gko {
13namespace matrix {
14
15
34template <typename ValueType = default_precision>
35class Identity : public EnableLinOp<Identity<ValueType>>, public Transposable {
36 friend class EnablePolymorphicObject<Identity, LinOp>;
37
38public:
39 using EnableLinOp<Identity>::convert_to;
40 using EnableLinOp<Identity>::move_to;
41
42 using value_type = ValueType;
43 using transposed_type = Identity<ValueType>;
44
45 std::unique_ptr<LinOp> transpose() const override;
46
47 std::unique_ptr<LinOp> conj_transpose() const override;
48
54 GKO_DEPRECATED("use the version taking a size_type instead of dim<2>")
55 static std::unique_ptr<Identity> create(
56 std::shared_ptr<const Executor> exec, dim<2> size);
57
63 static std::unique_ptr<Identity> create(
64 std::shared_ptr<const Executor> exec, size_type size = 0);
65
66protected:
67 explicit Identity(std::shared_ptr<const Executor> exec, size_type size = 0);
68
69 void apply_impl(const LinOp* b, LinOp* x) const override;
70
71 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
72 LinOp* x) const override;
73};
74
75
88template <typename ValueType = default_precision>
89class IdentityFactory
90 : public EnablePolymorphicObject<IdentityFactory<ValueType>, LinOpFactory> {
91 friend class EnablePolymorphicObject<IdentityFactory, LinOpFactory>;
92
93public:
94 using value_type = ValueType;
95
103 static std::unique_ptr<IdentityFactory> create(
104 std::shared_ptr<const Executor> exec)
105 {
106 return std::unique_ptr<IdentityFactory>(
107 new IdentityFactory(std::move(exec)));
108 }
109
110protected:
111 std::unique_ptr<LinOp> generate_impl(
112 std::shared_ptr<const LinOp> base) const override;
113
114 IdentityFactory(std::shared_ptr<const Executor> exec)
116 {}
117};
118
119
120} // namespace matrix
121} // namespace gko
122
123
124#endif // GKO_PUBLIC_CORE_MATRIX_IDENTITY_HPP_
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:879
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:668
The first step in using the Ginkgo library consists of creating an executor.
Definition executor.hpp:615
A LinOpFactory represents a higher order mapping which transforms one linear operator into another.
Definition lin_op.hpp:385
Definition lin_op.hpp:117
Linear operators which support transposition should implement the Transposable interface.
Definition lin_op.hpp:433
This factory is a utility which can be used to generate Identity operators.
Definition identity.hpp:90
static std::unique_ptr< IdentityFactory > create(std::shared_ptr< const Executor > exec)
Creates a new Identity factory.
Definition identity.hpp:103
static std::unique_ptr< Identity > create(std::shared_ptr< const Executor > exec, dim< 2 > size)
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.
The matrix namespace.
Definition dense_cache.hpp:24
The Ginkgo namespace.
Definition abstract_factory.hpp:20
double default_precision
Precision used if no precision is explicitly specified.
Definition types.hpp:172
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:90
STL namespace.
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:26