identity.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_MATRIX_IDENTITY_HPP_
#define GKO_PUBLIC_CORE_MATRIX_IDENTITY_HPP_
 
 
#include <ginkgo/core/base/lin_op.hpp>
 
 
namespace gko {
namespace matrix {
 
 
template <typename ValueType = default_precision>
class Identity : public EnableLinOp<Identity<ValueType>>, public Transposable {
    friend class EnablePolymorphicObject<Identity, LinOp>;
 
public:
    using EnableLinOp<Identity>::convert_to;
    using EnableLinOp<Identity>::move_to;
 
    using value_type = ValueType;
    using transposed_type = Identity<ValueType>;
 
    std::unique_ptr<LinOp> transpose() const override;
 
    std::unique_ptr<LinOp> conj_transpose() const override;
 
    GKO_DEPRECATED("use the version taking a size_type instead of dim<2>")
    static std::unique_ptr<Identity> create(
        std::shared_ptr<const Executor> exec, dim<2> size);
 
    static std::unique_ptr<Identity> create(
        std::shared_ptr<const Executor> exec, size_type size = 0);
 
protected:
    explicit Identity(std::shared_ptr<const Executor> exec, size_type size = 0);
 
    void apply_impl(const LinOp* b, LinOp* x) const override;
 
    void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
                    LinOp* x) const override;
};
 
 
template <typename ValueType = default_precision>
class IdentityFactory
    : public EnablePolymorphicObject<IdentityFactory<ValueType>, LinOpFactory> {
    friend class EnablePolymorphicObject<IdentityFactory, LinOpFactory>;
 
public:
    using value_type = ValueType;
 
    static std::unique_ptr<IdentityFactory> create(
        std::shared_ptr<const Executor> exec)
    {
        return std::unique_ptr<IdentityFactory>(
            new IdentityFactory(std::move(exec)));
    }
 
protected:
    std::unique_ptr<LinOp> generate_impl(
        std::shared_ptr<const LinOp> base) const override;
 
    IdentityFactory(std::shared_ptr<const Executor> exec)
        : EnablePolymorphicObject<IdentityFactory, LinOpFactory>(exec)
    {}
};
 
 
}  // namespace matrix
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_MATRIX_IDENTITY_HPP_