33#ifndef GKO_PUBLIC_CORE_BASE_LIN_OP_HPP_
34#define GKO_PUBLIC_CORE_BASE_LIN_OP_HPP_
42#include <ginkgo/core/base/abstract_factory.hpp>
43#include <ginkgo/core/base/device_matrix_data.hpp>
44#include <ginkgo/core/base/dim.hpp>
45#include <ginkgo/core/base/exception_helpers.hpp>
46#include <ginkgo/core/base/math.hpp>
47#include <ginkgo/core/base/matrix_assembly_data.hpp>
48#include <ginkgo/core/base/matrix_data.hpp>
49#include <ginkgo/core/base/polymorphic_object.hpp>
50#include <ginkgo/core/base/types.hpp>
51#include <ginkgo/core/base/utils.hpp>
52#include <ginkgo/core/log/logger.hpp>
59template <
typename ValueType>
162 this->validate_application_parameters(b.
get(), x.
get());
178 this->validate_application_parameters(b.
get(), x.
get());
202 this->validate_application_parameters(alpha.
get(), b.
get(), beta.
get(),
222 this->validate_application_parameters(alpha.
get(), b.
get(), beta.
get(),
260 if (
this != &
other) {
262 this->set_size(
other.get_size());
287 explicit LinOp(std::shared_ptr<const Executor> exec,
288 const dim<2>& size = dim<2>{})
289 : EnableAbstractPolymorphicObject<LinOp>(exec), size_{size}
297 void set_size(
const dim<2>& value)
noexcept { size_ = value; }
308 virtual void apply_impl(
const LinOp* b, LinOp* x)
const = 0;
319 virtual void apply_impl(
const LinOp* alpha,
const LinOp* b,
320 const LinOp* beta, LinOp* x)
const = 0;
329 void validate_application_parameters(
const LinOp* b,
const LinOp* x)
const
331 GKO_ASSERT_CONFORMANT(
this, b);
332 GKO_ASSERT_EQUAL_ROWS(
this, x);
333 GKO_ASSERT_EQUAL_COLS(b, x);
345 void validate_application_parameters(
const LinOp* alpha,
const LinOp* b,
347 const LinOp* x)
const
349 this->validate_application_parameters(b, x);
350 GKO_ASSERT_EQUAL_DIMENSIONS(alpha, dim<2>(1, 1));
351 GKO_ASSERT_EQUAL_DIMENSIONS(beta, dim<2>(1, 1));
418 std::unique_ptr<LinOp> generate(std::shared_ptr<const LinOp> input)
const
420 this->
template log<log::Logger::linop_factory_generate_started>(
422 const auto exec = this->get_executor();
423 std::unique_ptr<LinOp> generated;
424 if (input->get_executor() == exec) {
425 generated = this->AbstractFactory::generate(input);
428 this->AbstractFactory::generate(
gko::clone(exec, input));
430 this->
template log<log::Logger::linop_factory_generate_completed>(
431 this, input.get(), generated.get());
512template <
typename IndexType>
534 return as<Permutable>(this->row_permute(permutation_indices))
535 ->column_permute(permutation_indices);
555 return as<Permutable>(this->inverse_row_permute(permutation_indices))
556 ->inverse_column_permute(permutation_indices);
633template <
typename ValueType,
typename IndexType>
636 using value_type = ValueType;
637 using index_type = IndexType;
676 this->
read(data.copy_to_host());
688template <
typename ValueType,
typename IndexType>
691 using value_type = ValueType;
692 using index_type = IndexType;
722 return preconditioner_;
733 preconditioner_ = new_precond;
737 std::shared_ptr<const LinOp> preconditioner_{};
771template <
typename ValueType>
774 using value_type = ValueType;
822template <
typename AbsoluteLinOp>
825 using absolute_type = AbsoluteLinOp;
831 return this->compute_absolute();
859 GKO_ASSERT_IS_SCALAR(a);
860 GKO_ASSERT_IS_SCALAR(b);
863 add_scaled_identity_impl(ae.get(), be.get());
867 virtual void add_scaled_identity_impl(
const LinOp* a,
const LinOp* b) = 0;
905template <
typename ConcreteLinOp,
typename PolymorphicBase = LinOp>
911 PolymorphicBase>::EnablePolymorphicObject;
916 PolymorphicBase::apply(b, x);
922 PolymorphicBase::apply(b, x);
931 PolymorphicBase::apply(alpha, b, beta, x);
938 PolymorphicBase::apply(alpha, b, beta, x);
943 GKO_ENABLE_SELF(ConcreteLinOp);
964template <
typename ConcreteFactory,
typename ConcreteLinOp,
965 typename ParametersType,
typename PolymorphicBase =
LinOpFactory>
1046#define GKO_ENABLE_LIN_OP_FACTORY(_lin_op, _parameters_name, _factory_name) \
1048 const _parameters_name##_type& get_##_parameters_name() const \
1050 return _parameters_name##_; \
1053 class _factory_name \
1054 : public ::gko::EnableDefaultLinOpFactory<_factory_name, _lin_op, \
1055 _parameters_name##_type> { \
1056 friend class ::gko::EnablePolymorphicObject<_factory_name, \
1057 ::gko::LinOpFactory>; \
1058 friend class ::gko::enable_parameters_type<_parameters_name##_type, \
1060 explicit _factory_name(std::shared_ptr<const ::gko::Executor> exec) \
1061 : ::gko::EnableDefaultLinOpFactory<_factory_name, _lin_op, \
1062 _parameters_name##_type>( \
1065 explicit _factory_name(std::shared_ptr<const ::gko::Executor> exec, \
1066 const _parameters_name##_type& parameters) \
1067 : ::gko::EnableDefaultLinOpFactory<_factory_name, _lin_op, \
1068 _parameters_name##_type>( \
1069 std::move(exec), parameters) \
1072 friend ::gko::EnableDefaultLinOpFactory<_factory_name, _lin_op, \
1073 _parameters_name##_type>; \
1077 _parameters_name##_type _parameters_name##_; \
1080 static_assert(true, \
1081 "This assert is used to counter the false positive extra " \
1082 "semi-colon warnings")
The AbsoluteComputable is an interface that allows to get the component wise absolute of a LinOp.
Definition lin_op.hpp:795
virtual void compute_absolute_inplace()=0
Compute absolute inplace on each element.
virtual std::unique_ptr< LinOp > compute_absolute_linop() const =0
Gets the absolute LinOp.
The AbstractFactory is a generic interface template that enables easy implementation of the abstract ...
Definition abstract_factory.hpp:75
The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop an...
Definition lin_op.hpp:823
virtual std::unique_ptr< absolute_type > compute_absolute() const =0
Gets the AbsoluteLinOp.
std::unique_ptr< LinOp > compute_absolute_linop() const override
Gets the absolute LinOp.
Definition lin_op.hpp:829
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:374
This mixin provides a default implementation of a concrete factory.
Definition abstract_factory.hpp:154
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:908
This mixin is used to enable a default PolymorphicObject::copy_from() implementation for objects that...
Definition polymorphic_object.hpp:752
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:691
A LinOpFactory represents a higher order mapping which transforms one linear operator into another.
Definition lin_op.hpp:414
Definition lin_op.hpp:146
LinOp * apply(ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x)
Performs the operation x = alpha * op(b) + beta * x.
Definition lin_op.hpp:197
LinOp(const LinOp &)=default
Copy-constructs a LinOp.
virtual bool apply_uses_initial_guess() const
Returns true if the linear operator uses the data given in x as an initial guess.
Definition lin_op.hpp:248
LinOp * apply(ptr_param< const LinOp > b, ptr_param< LinOp > x)
Applies a linear operator to a vector (or a sequence of vectors).
Definition lin_op.hpp:158
const dim< 2 > & get_size() const noexcept
Returns the size of the operator.
Definition lin_op.hpp:239
LinOp(LinOp &&other)
Move-constructs a LinOp.
Definition lin_op.hpp:275
LinOp & operator=(LinOp &&other)
Move-assigns a LinOp.
Definition lin_op.hpp:258
const LinOp * apply(ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Definition lin_op.hpp:174
const LinOp * apply(ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const
Definition lin_op.hpp:217
LinOp & operator=(const LinOp &)=default
Copy-assigns a LinOp.
Linear operators which support permutation should implement the Permutable interface.
Definition lin_op.hpp:513
virtual std::unique_ptr< LinOp > inverse_column_permute(const array< IndexType > *permutation_indices) const =0
Returns a LinOp representing the row permutation of the inverse permuted object.
virtual std::unique_ptr< LinOp > row_permute(const array< IndexType > *permutation_indices) const =0
Returns a LinOp representing the row permutation of the Permutable object.
virtual std::unique_ptr< LinOp > inverse_row_permute(const array< IndexType > *permutation_indices) const =0
Returns a LinOp representing the row permutation of the inverse permuted object.
virtual std::unique_ptr< LinOp > inverse_permute(const array< IndexType > *permutation_indices) const
Returns a LinOp representing the symmetric inverse row and column permutation of the Permutable objec...
Definition lin_op.hpp:552
virtual std::unique_ptr< LinOp > column_permute(const array< IndexType > *permutation_indices) const =0
Returns a LinOp representing the column permutation of the Permutable object.
virtual std::unique_ptr< LinOp > permute(const array< IndexType > *permutation_indices) const
Returns a LinOp representing the symmetric row and column permutation of the Permutable object.
Definition lin_op.hpp:531
std::shared_ptr< const Executor > get_executor() const noexcept
Returns the Executor of the object.
Definition polymorphic_object.hpp:263
A LinOp implementing this interface can be preconditioned.
Definition lin_op.hpp:711
virtual void set_preconditioner(std::shared_ptr< const LinOp > new_precond)
Sets the preconditioner operator used by the Preconditionable.
Definition lin_op.hpp:731
virtual std::shared_ptr< const LinOp > get_preconditioner() const
Returns the preconditioner operator used by the Preconditionable.
Definition lin_op.hpp:720
A LinOp implementing this interface can read its data from a matrix_data structure.
Definition lin_op.hpp:634
virtual void read(const device_matrix_data< ValueType, IndexType > &data)
Reads a matrix from a device_matrix_data structure.
Definition lin_op.hpp:663
virtual void read(device_matrix_data< ValueType, IndexType > &&data)
Reads a matrix from a device_matrix_data structure.
Definition lin_op.hpp:674
void read(const matrix_assembly_data< ValueType, IndexType > &data)
Reads a matrix from a matrix_assembly_data structure.
Definition lin_op.hpp:653
virtual void read(const matrix_data< ValueType, IndexType > &data)=0
Reads a matrix from a matrix_data structure.
Adds the operation M <- a I + b M for matrix M, identity operator I and scalars a and b,...
Definition lin_op.hpp:847
void add_scaled_identity(ptr_param< const LinOp > const a, ptr_param< const LinOp > const b)
Scales this and adds another scalar times the identity to it.
Definition lin_op.hpp:856
Linear operators which support transposition should implement the Transposable interface.
Definition lin_op.hpp:462
virtual std::unique_ptr< LinOp > conj_transpose() const =0
Returns a LinOp representing the conjugate transpose of the Transposable object.
virtual std::unique_ptr< LinOp > transpose() const =0
Returns a LinOp representing the transpose of the Transposable object.
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:689
virtual void write(matrix_data< ValueType, IndexType > &data) const =0
Writes a matrix to a matrix_data structure.
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:187
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:63
host_type copy_to_host() const
Copies the device_matrix_data entries to the host to return a regular matrix_data object with the sam...
This structure is used as an intermediate type to assemble a sparse matrix.
Definition matrix_assembly_data.hpp:88
matrix_data< ValueType, IndexType > get_ordered_data() const
Definition matrix_assembly_data.hpp:169
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:71
T * get() const
Definition utils_helper.hpp:105
The Ginkgo namespace.
Definition abstract_factory.hpp:48
constexpr T one()
Returns the multiplicative identity for T.
Definition math.hpp:803
detail::cloned_type< Pointer > clone(const Pointer &p)
Creates a unique clone of the object pointed to by p.
Definition utils_helper.hpp:203
std::unique_ptr< MatrixType > read(StreamType &&is, MatrixArgs &&... args)
Reads a matrix stored in matrix market format from an input stream.
Definition mtx_io.hpp:188
detail::temporary_clone< detail::pointee< Ptr > > make_temporary_clone(std::shared_ptr< const Executor > exec, Ptr &&ptr)
Creates a temporary_clone.
Definition temporary_clone.hpp:207
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:55
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:155