ginkgo-hpc/html/dense_8hpp_source.html

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors

//

// SPDX-License-Identifier: BSD-3-Clause


#ifndef GKO_PUBLIC_CORE_MATRIX_DENSE_HPP_

#define GKO_PUBLIC_CORE_MATRIX_DENSE_HPP_


#include <initializer_list>

#include <type_traits>


#include <ginkgo/core/base/array.hpp>

#include <ginkgo/core/base/exception_helpers.hpp>

#include <ginkgo/core/base/executor.hpp>

#include <ginkgo/core/base/lin_op.hpp>

#include <ginkgo/core/base/range_accessors.hpp>

#include <ginkgo/core/base/types.hpp>

#include <ginkgo/core/base/utils.hpp>

#include <ginkgo/core/matrix/permutation.hpp>

#include <ginkgo/core/matrix/scaled_permutation.hpp>


namespace gko {

namespace experimental {

namespace distributed {


template <typename ValueType>

class Vector;


namespace detail {


template <typename ValueType>

class VectorCache;


}  // namespace detail

}  // namespace distributed

}  // namespace experimental


namespace matrix {


template <typename ValueType, typename IndexType>

class Coo;


template <typename ValueType, typename IndexType>

class Csr;


template <typename ValueType>

class Diagonal;


template <typename ValueType, typename IndexType>

class Ell;


template <typename ValueType, typename IndexType>

class Fbcsr;


template <typename ValueType, typename IndexType>

class Hybrid;


template <typename ValueType, typename IndexType>

class Sellp;


template <typename ValueType, typename IndexType>

class SparsityCsr;


template <typename ValueType = default_precision>


class Dense

    : public EnableLinOp<Dense<ValueType>>,

      public ConvertibleTo<Dense<next_precision<ValueType>>>,

#if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16

      public ConvertibleTo<Dense<next_precision<ValueType, 2>>>,

#endif

#if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16

      public ConvertibleTo<Dense<next_precision<ValueType, 3>>>,

#endif

      public ConvertibleTo<Coo<ValueType, int32>>,

      public ConvertibleTo<Coo<ValueType, int64>>,

      public ConvertibleTo<Csr<ValueType, int32>>,

      public ConvertibleTo<Csr<ValueType, int64>>,

      public ConvertibleTo<Ell<ValueType, int32>>,

      public ConvertibleTo<Ell<ValueType, int64>>,

      public ConvertibleTo<Fbcsr<ValueType, int32>>,

      public ConvertibleTo<Fbcsr<ValueType, int64>>,

      public ConvertibleTo<Hybrid<ValueType, int32>>,

      public ConvertibleTo<Hybrid<ValueType, int64>>,

      public ConvertibleTo<Sellp<ValueType, int32>>,

      public ConvertibleTo<Sellp<ValueType, int64>>,

      public ConvertibleTo<SparsityCsr<ValueType, int32>>,

      public ConvertibleTo<SparsityCsr<ValueType, int64>>,

      public DiagonalExtractable<ValueType>,

      public ReadableFromMatrixData<ValueType, int32>,

      public ReadableFromMatrixData<ValueType, int64>,

      public WritableToMatrixData<ValueType, int32>,

      public WritableToMatrixData<ValueType, int64>,

      public Transposable,

      public Permutable<int32>,

      public Permutable<int64>,

      public EnableAbsoluteComputation<remove_complex<Dense<ValueType>>>,

      public ScaledIdentityAddable {

    friend class EnablePolymorphicObject<Dense, LinOp>;

    friend class Coo<ValueType, int32>;

    friend class Coo<ValueType, int64>;

    friend class Csr<ValueType, int32>;

    friend class Csr<ValueType, int64>;

    friend class Diagonal<ValueType>;

    friend class Ell<ValueType, int32>;

    friend class Ell<ValueType, int64>;

    friend class Fbcsr<ValueType, int32>;

    friend class Fbcsr<ValueType, int64>;

    friend class Hybrid<ValueType, int32>;

    friend class Hybrid<ValueType, int64>;

    friend class Sellp<ValueType, int32>;

    friend class Sellp<ValueType, int64>;

    friend class SparsityCsr<ValueType, int32>;

    friend class SparsityCsr<ValueType, int64>;

    friend class Dense<to_complex<ValueType>>;

    friend class experimental::distributed::Vector<ValueType>;

    friend class experimental::distributed::detail::VectorCache<ValueType>;

    GKO_ASSERT_SUPPORTED_VALUE_TYPE;


public:

    using EnableLinOp<Dense>::convert_to;

    using EnableLinOp<Dense>::move_to;

    using ConvertibleTo<Dense<next_precision<ValueType>>>::convert_to;

    using ConvertibleTo<Dense<next_precision<ValueType>>>::move_to;

    using ConvertibleTo<Coo<ValueType, int32>>::convert_to;

    using ConvertibleTo<Coo<ValueType, int32>>::move_to;

    using ConvertibleTo<Coo<ValueType, int64>>::convert_to;

    using ConvertibleTo<Coo<ValueType, int64>>::move_to;

    using ConvertibleTo<Csr<ValueType, int32>>::convert_to;

    using ConvertibleTo<Csr<ValueType, int32>>::move_to;

    using ConvertibleTo<Csr<ValueType, int64>>::convert_to;

    using ConvertibleTo<Csr<ValueType, int64>>::move_to;

    using ConvertibleTo<Ell<ValueType, int32>>::convert_to;

    using ConvertibleTo<Ell<ValueType, int32>>::move_to;

    using ConvertibleTo<Ell<ValueType, int64>>::convert_to;

    using ConvertibleTo<Ell<ValueType, int64>>::move_to;

    using ConvertibleTo<Fbcsr<ValueType, int32>>::convert_to;

    using ConvertibleTo<Fbcsr<ValueType, int32>>::move_to;

    using ConvertibleTo<Fbcsr<ValueType, int64>>::convert_to;

    using ConvertibleTo<Fbcsr<ValueType, int64>>::move_to;

    using ConvertibleTo<Hybrid<ValueType, int32>>::convert_to;

    using ConvertibleTo<Hybrid<ValueType, int32>>::move_to;

    using ConvertibleTo<Hybrid<ValueType, int64>>::convert_to;

    using ConvertibleTo<Hybrid<ValueType, int64>>::move_to;

    using ConvertibleTo<Sellp<ValueType, int32>>::convert_to;

    using ConvertibleTo<Sellp<ValueType, int32>>::move_to;

    using ConvertibleTo<Sellp<ValueType, int64>>::convert_to;

    using ConvertibleTo<Sellp<ValueType, int64>>::move_to;

    using ConvertibleTo<SparsityCsr<ValueType, int32>>::convert_to;

    using ConvertibleTo<SparsityCsr<ValueType, int32>>::move_to;

    using ConvertibleTo<SparsityCsr<ValueType, int64>>::convert_to;

    using ConvertibleTo<SparsityCsr<ValueType, int64>>::move_to;

    using ReadableFromMatrixData<ValueType, int32>::read;

    using ReadableFromMatrixData<ValueType, int64>::read;


    using value_type = ValueType;

    using index_type = int64;

    using transposed_type = Dense<ValueType>;

    using mat_data = matrix_data<ValueType, int64>;

    using mat_data32 = matrix_data<ValueType, int32>;

    using device_mat_data = device_matrix_data<ValueType, int64>;

    using device_mat_data32 = device_matrix_data<ValueType, int32>;

    using absolute_type = remove_complex<Dense>;

    using real_type = absolute_type;

    using complex_type = to_complex<Dense>;


    using row_major_range = gko::range<gko::accessor::row_major<ValueType, 2>>;


    static std::unique_ptr<Dense> create_with_config_of(

        ptr_param<const Dense> other)

    {

        // De-referencing `other` before calling the functions (instead of

        // using operator `->`) is currently required to be compatible with

        // CUDA 10.1.

        // Otherwise, it results in a compile error.

        return (*other).create_with_same_config();

    }


    static std::unique_ptr<Dense> create_with_type_of(

        ptr_param<const Dense> other, std::shared_ptr<const Executor> exec,

        const dim<2>& size = dim<2>{})

    {

        // See create_with_config_of()

        return (*other).create_with_type_of_impl(exec, size, size[1]);

    }


    static std::unique_ptr<Dense> create_with_type_of(

        ptr_param<const Dense> other, std::shared_ptr<const Executor> exec,

        const dim<2>& size, size_type stride)

    {

        // See create_with_config_of()

        return (*other).create_with_type_of_impl(exec, size, stride);

    }


    static std::unique_ptr<Dense> create_with_type_of(

        ptr_param<const Dense> other, std::shared_ptr<const Executor> exec,

        const dim<2>& size, const dim<2>& local_size, size_type stride)

    {

        // See create_with_config_of()

        return (*other).create_with_type_of_impl(exec, size, stride);

    }


    static std::unique_ptr<Dense> create_view_of(ptr_param<Dense> other)

    {

        return other->create_view_of_impl();

    }


    static std::unique_ptr<const Dense> create_const_view_of(

        ptr_param<const Dense> other)

    {

        return other->create_const_view_of_impl();

    }


    friend class Dense<previous_precision<ValueType>>;


    void convert_to(Dense<next_precision<ValueType>>* result) const override;


    void move_to(Dense<next_precision<ValueType>>* result) override;


#if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16

    friend class Dense<previous_precision<ValueType, 2>>;

    using ConvertibleTo<Dense<next_precision<ValueType, 2>>>::convert_to;

    using ConvertibleTo<Dense<next_precision<ValueType, 2>>>::move_to;


    void convert_to(Dense<next_precision<ValueType, 2>>* result) const override;


    void move_to(Dense<next_precision<ValueType, 2>>* result) override;

#endif


#if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16

    friend class Dense<previous_precision<ValueType, 3>>;

    using ConvertibleTo<Dense<next_precision<ValueType, 3>>>::convert_to;

    using ConvertibleTo<Dense<next_precision<ValueType, 3>>>::move_to;


    void convert_to(Dense<next_precision<ValueType, 3>>* result) const override;


    void move_to(Dense<next_precision<ValueType, 3>>* result) override;

#endif


    void convert_to(Coo<ValueType, int32>* result) const override;


    void move_to(Coo<ValueType, int32>* result) override;


    void convert_to(Coo<ValueType, int64>* result) const override;


    void move_to(Coo<ValueType, int64>* result) override;


    void convert_to(Csr<ValueType, int32>* result) const override;


    void move_to(Csr<ValueType, int32>* result) override;


    void convert_to(Csr<ValueType, int64>* result) const override;


    void move_to(Csr<ValueType, int64>* result) override;


    void convert_to(Ell<ValueType, int32>* result) const override;


    void move_to(Ell<ValueType, int32>* result) override;


    void convert_to(Ell<ValueType, int64>* result) const override;


    void move_to(Ell<ValueType, int64>* result) override;


    void convert_to(Fbcsr<ValueType, int32>* result) const override;


    void move_to(Fbcsr<ValueType, int32>* result) override;


    void convert_to(Fbcsr<ValueType, int64>* result) const override;


    void move_to(Fbcsr<ValueType, int64>* result) override;


    void convert_to(Hybrid<ValueType, int32>* result) const override;


    void move_to(Hybrid<ValueType, int32>* result) override;


    void convert_to(Hybrid<ValueType, int64>* result) const override;


    void move_to(Hybrid<ValueType, int64>* result) override;


    void convert_to(Sellp<ValueType, int32>* result) const override;


    void move_to(Sellp<ValueType, int32>* result) override;


    void convert_to(Sellp<ValueType, int64>* result) const override;


    void move_to(Sellp<ValueType, int64>* result) override;


    void convert_to(SparsityCsr<ValueType, int32>* result) const override;


    void move_to(SparsityCsr<ValueType, int32>* result) override;


    void convert_to(SparsityCsr<ValueType, int64>* result) const override;


    void move_to(SparsityCsr<ValueType, int64>* result) override;


    void read(const mat_data& data) override;


    void read(const mat_data32& data) override;


    void read(const device_mat_data& data) override;


    void read(const device_mat_data32& data) override;


    void read(device_mat_data&& data) override;


    void read(device_mat_data32&& data) override;


    void write(mat_data& data) const override;


    void write(mat_data32& data) const override;


    std::unique_ptr<LinOp> transpose() const override;


    std::unique_ptr<LinOp> conj_transpose() const override;


    void transpose(ptr_param<Dense> output) const;


    void conj_transpose(ptr_param<Dense> output) const;


    void fill(const ValueType value);


    std::unique_ptr<Dense> permute(

        ptr_param<const Permutation<int32>> permutation,

        permute_mode mode = permute_mode::symmetric) const;


    std::unique_ptr<Dense> permute(

        ptr_param<const Permutation<int64>> permutation,

        permute_mode mode = permute_mode::symmetric) const;


    void permute(ptr_param<const Permutation<int32>> permutation,

                 ptr_param<Dense> output, permute_mode mode) const;


    void permute(ptr_param<const Permutation<int64>> permutation,

                 ptr_param<Dense> output, permute_mode mode) const;


    std::unique_ptr<Dense> permute(

        ptr_param<const Permutation<int32>> row_permutation,

        ptr_param<const Permutation<int32>> column_permutation,

        bool invert = false) const;


    std::unique_ptr<Dense> permute(

        ptr_param<const Permutation<int64>> row_permutation,

        ptr_param<const Permutation<int64>> column_permutation,

        bool invert = false) const;


    void permute(ptr_param<const Permutation<int32>> row_permutation,

                 ptr_param<const Permutation<int32>> column_permutation,

                 ptr_param<Dense> output, bool invert = false) const;


    void permute(ptr_param<const Permutation<int64>> row_permutation,

                 ptr_param<const Permutation<int64>> column_permutation,

                 ptr_param<Dense> output, bool invert = false) const;


    std::unique_ptr<Dense> scale_permute(

        ptr_param<const ScaledPermutation<value_type, int32>> permutation,

        permute_mode mode = permute_mode::symmetric) const;


    std::unique_ptr<Dense> scale_permute(

        ptr_param<const ScaledPermutation<value_type, int64>> permutation,

        permute_mode mode = permute_mode::symmetric) const;


    void scale_permute(

        ptr_param<const ScaledPermutation<value_type, int32>> permutation,

        ptr_param<Dense> output, permute_mode mode) const;


    void scale_permute(

        ptr_param<const ScaledPermutation<value_type, int64>> permutation,

        ptr_param<Dense> output, permute_mode mode) const;


    std::unique_ptr<Dense> scale_permute(

        ptr_param<const ScaledPermutation<value_type, int32>> row_permutation,

        ptr_param<const ScaledPermutation<value_type, int32>>

            column_permutation,

        bool invert = false) const;


    std::unique_ptr<Dense> scale_permute(

        ptr_param<const ScaledPermutation<value_type, int64>> row_permutation,

        ptr_param<const ScaledPermutation<value_type, int64>>

            column_permutation,

        bool invert = false) const;


    void scale_permute(

        ptr_param<const ScaledPermutation<value_type, int32>> row_permutation,

        ptr_param<const ScaledPermutation<value_type, int32>>

            column_permutation,

        ptr_param<Dense> output, bool invert = false) const;


    void scale_permute(

        ptr_param<const ScaledPermutation<value_type, int64>> row_permutation,

        ptr_param<const ScaledPermutation<value_type, int64>>

            column_permutation,

        ptr_param<Dense> output, bool invert = false) const;


    std::unique_ptr<LinOp> permute(

        const array<int32>* permutation_indices) const override;


    std::unique_ptr<LinOp> permute(

        const array<int64>* permutation_indices) const override;


    void permute(const array<int32>* permutation_indices,

                 ptr_param<Dense> output) const;


    void permute(const array<int64>* permutation_indices,

                 ptr_param<Dense> output) const;


    std::unique_ptr<LinOp> inverse_permute(

        const array<int32>* permutation_indices) const override;


    std::unique_ptr<LinOp> inverse_permute(

        const array<int64>* permutation_indices) const override;


    void inverse_permute(const array<int32>* permutation_indices,

                         ptr_param<Dense> output) const;


    void inverse_permute(const array<int64>* permutation_indices,

                         ptr_param<Dense> output) const;


    std::unique_ptr<LinOp> row_permute(

        const array<int32>* permutation_indices) const override;


    std::unique_ptr<LinOp> row_permute(

        const array<int64>* permutation_indices) const override;


    void row_permute(const array<int32>* permutation_indices,

                     ptr_param<Dense> output) const;


    void row_permute(const array<int64>* permutation_indices,

                     ptr_param<Dense> output) const;


    std::unique_ptr<Dense> row_gather(const array<int32>* gather_indices) const;


    std::unique_ptr<Dense> row_gather(const array<int64>* gather_indices) const;


    void row_gather(const array<int32>* gather_indices,

                    ptr_param<LinOp> row_collection) const;


    void row_gather(const array<int64>* gather_indices,

                    ptr_param<LinOp> row_collection) const;


    void row_gather(ptr_param<const LinOp> alpha,

                    const array<int32>* gather_indices,

                    ptr_param<const LinOp> beta,

                    ptr_param<LinOp> row_collection) const;


    void row_gather(ptr_param<const LinOp> alpha,

                    const array<int64>* gather_indices,

                    ptr_param<const LinOp> beta,

                    ptr_param<LinOp> row_collection) const;


    std::unique_ptr<LinOp> column_permute(

        const array<int32>* permutation_indices) const override;


    std::unique_ptr<LinOp> column_permute(

        const array<int64>* permutation_indices) const override;


    void column_permute(const array<int32>* permutation_indices,

                        ptr_param<Dense> output) const;


    void column_permute(const array<int64>* permutation_indices,

                        ptr_param<Dense> output) const;


    std::unique_ptr<LinOp> inverse_row_permute(

        const array<int32>* permutation_indices) const override;


    std::unique_ptr<LinOp> inverse_row_permute(

        const array<int64>* permutation_indices) const override;


    void inverse_row_permute(const array<int32>* permutation_indices,

                             ptr_param<Dense> output) const;


    void inverse_row_permute(const array<int64>* permutation_indices,

                             ptr_param<Dense> output) const;


    std::unique_ptr<LinOp> inverse_column_permute(

        const array<int32>* permutation_indices) const override;


    std::unique_ptr<LinOp> inverse_column_permute(

        const array<int64>* permutation_indices) const override;


    void inverse_column_permute(const array<int32>* permutation_indices,

                                ptr_param<Dense> output) const;


    void inverse_column_permute(const array<int64>* permutation_indices,

                                ptr_param<Dense> output) const;


    std::unique_ptr<Diagonal<ValueType>> extract_diagonal() const override;


    void extract_diagonal(ptr_param<Diagonal<ValueType>> output) const;


    std::unique_ptr<absolute_type> compute_absolute() const override;


    void compute_absolute(ptr_param<absolute_type> output) const;


    void compute_absolute_inplace() override;


    std::unique_ptr<complex_type> make_complex() const;


    void make_complex(ptr_param<complex_type> result) const;


    std::unique_ptr<real_type> get_real() const;


    void get_real(ptr_param<real_type> result) const;


    std::unique_ptr<real_type> get_imag() const;


    void get_imag(ptr_param<real_type> result) const;


    value_type* get_values() noexcept { return values_.get_data(); }


    const value_type* get_const_values() const noexcept

    {

        return values_.get_const_data();

    }


    size_type get_stride() const noexcept { return stride_; }


    size_type get_num_stored_elements() const noexcept

    {

        return values_.get_size();

    }


    value_type& at(size_type row, size_type col) noexcept

    {

        return values_.get_data()[linearize_index(row, col)];

    }


    value_type at(size_type row, size_type col) const noexcept

    {

        return values_.get_const_data()[linearize_index(row, col)];

    }


    ValueType& at(size_type idx) noexcept

    {

        return values_.get_data()[linearize_index(idx)];

    }


    ValueType at(size_type idx) const noexcept

    {

        return values_.get_const_data()[linearize_index(idx)];

    }


    void scale(ptr_param<const LinOp> alpha);


    void inv_scale(ptr_param<const LinOp> alpha);


    void add_scaled(ptr_param<const LinOp> alpha, ptr_param<const LinOp> b);


    void sub_scaled(ptr_param<const LinOp> alpha, ptr_param<const LinOp> b);


    void compute_dot(ptr_param<const LinOp> b, ptr_param<LinOp> result) const;


    void compute_dot(ptr_param<const LinOp> b, ptr_param<LinOp> result,

                     array<char>& tmp) const;


    void compute_conj_dot(ptr_param<const LinOp> b,

                          ptr_param<LinOp> result) const;


    void compute_conj_dot(ptr_param<const LinOp> b, ptr_param<LinOp> result,

                          array<char>& tmp) const;


    void compute_norm2(ptr_param<LinOp> result) const;


    void compute_norm2(ptr_param<LinOp> result, array<char>& tmp) const;


    void compute_norm1(ptr_param<LinOp> result) const;


    void compute_norm1(ptr_param<LinOp> result, array<char>& tmp) const;


    void compute_squared_norm2(ptr_param<LinOp> result) const;


    void compute_squared_norm2(ptr_param<LinOp> result, array<char>& tmp) const;


    void compute_mean(ptr_param<LinOp> result) const;


    void compute_mean(ptr_param<LinOp> result, array<char>& tmp) const;


    std::unique_ptr<Dense> create_submatrix(const span& rows,

                                            const span& columns,

                                            const size_type stride)

    {

        return this->create_submatrix_impl(rows, columns, stride);

    }


    std::unique_ptr<Dense> create_submatrix(const span& rows,

                                            const span& columns)

    {

        return create_submatrix(rows, columns, this->get_stride());

    }


    std::unique_ptr<Dense> create_submatrix(const local_span& rows,

                                            const local_span& columns,

                                            dim<2> size)

    {

        dim<2> deduced_size{rows.length(), columns.length()};

        GKO_ASSERT_EQUAL_DIMENSIONS(deduced_size, size);

        return create_submatrix(rows, columns, this->get_stride());

    }


    std::unique_ptr<real_type> create_real_view();


    std::unique_ptr<const real_type> create_real_view() const;


    static std::unique_ptr<Dense> create(std::shared_ptr<const Executor> exec,

                                         const dim<2>& size = {},

                                         size_type stride = 0);


    static std::unique_ptr<Dense> create(std::shared_ptr<const Executor> exec,

                                         const dim<2>& size,

                                         array<value_type> values,

                                         size_type stride);


    template <typename InputValueType>

    GKO_DEPRECATED(

        "explicitly construct the gko::array argument instead of passing an"

        "initializer list")


    static std::unique_ptr<Dense> create(

        std::shared_ptr<const Executor> exec, const dim<2>& size,

        std::initializer_list<InputValueType> values, size_type stride)

    {

        return create(exec, size, array<value_type>{exec, std::move(values)},

                      stride);

    }


    static std::unique_ptr<const Dense> create_const(

        std::shared_ptr<const Executor> exec, const dim<2>& size,

        gko::detail::const_array_view<ValueType>&& values, size_type stride);


    Dense& operator=(const Dense&);


    Dense& operator=(Dense&&);


    Dense(const Dense&);


    Dense(Dense&&);


protected:

    Dense(std::shared_ptr<const Executor> exec, const dim<2>& size = {},

          size_type stride = 0);


    Dense(std::shared_ptr<const Executor> exec, const dim<2>& size,

          array<value_type> values, size_type stride);


    virtual std::unique_ptr<Dense> create_with_same_config() const

    {

        return Dense::create(this->get_executor(), this->get_size(),

                             this->get_stride());

    }


    virtual std::unique_ptr<Dense> create_with_type_of_impl(

        std::shared_ptr<const Executor> exec, const dim<2>& size,

        size_type stride) const

    {

        return Dense::create(exec, size, stride);

    }


    virtual std::unique_ptr<Dense> create_view_of_impl()

    {

        auto exec = this->get_executor();

        return Dense::create(

            exec, this->get_size(),

            gko::make_array_view(exec, this->get_num_stored_elements(),

                                 this->get_values()),

            this->get_stride());

    }


    virtual std::unique_ptr<const Dense> create_const_view_of_impl() const

    {

        auto exec = this->get_executor();

        return Dense::create_const(

            exec, this->get_size(),

            gko::make_const_array_view(exec, this->get_num_stored_elements(),

                                       this->get_const_values()),

            this->get_stride());

    }


    template <typename IndexType>

    void convert_impl(Coo<ValueType, IndexType>* result) const;


    template <typename IndexType>

    void convert_impl(Csr<ValueType, IndexType>* result) const;


    template <typename IndexType>

    void convert_impl(Ell<ValueType, IndexType>* result) const;


    template <typename IndexType>

    void convert_impl(Fbcsr<ValueType, IndexType>* result) const;


    template <typename IndexType>

    void convert_impl(Hybrid<ValueType, IndexType>* result) const;


    template <typename IndexType>

    void convert_impl(Sellp<ValueType, IndexType>* result) const;


    template <typename IndexType>

    void convert_impl(SparsityCsr<ValueType, IndexType>* result) const;


    virtual void scale_impl(const LinOp* alpha);


    virtual void inv_scale_impl(const LinOp* alpha);


    virtual void add_scaled_impl(const LinOp* alpha, const LinOp* b);


    virtual void sub_scaled_impl(const LinOp* alpha, const LinOp* b);


    virtual void compute_dot_impl(const LinOp* b, LinOp* result) const;


    virtual void compute_conj_dot_impl(const LinOp* b, LinOp* result) const;


    virtual void compute_norm2_impl(LinOp* result) const;


    virtual void compute_norm1_impl(LinOp* result) const;


    virtual void compute_squared_norm2_impl(LinOp* result) const;


    virtual void compute_mean_impl(LinOp* result) const;


    void resize(gko::dim<2> new_size);


    virtual std::unique_ptr<Dense> create_submatrix_impl(

        const span& rows, const span& columns, const size_type stride);


    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;


    size_type linearize_index(size_type row, size_type col) const noexcept

    {

        return row * stride_ + col;

    }


    size_type linearize_index(size_type idx) const noexcept

    {

        return linearize_index(idx / this->get_size()[1],

                               idx % this->get_size()[1]);

    }


    template <typename IndexType>

    void permute_impl(const Permutation<IndexType>* permutation,

                      permute_mode mode, Dense* output) const;


    template <typename IndexType>

    void permute_impl(const Permutation<IndexType>* row_permutation,

                      const Permutation<IndexType>* col_permutation,

                      bool invert, Dense* output) const;


    template <typename IndexType>

    void scale_permute_impl(

        const ScaledPermutation<ValueType, IndexType>* permutation,

        permute_mode mode, Dense* output) const;


    template <typename IndexType>

    void scale_permute_impl(

        const ScaledPermutation<ValueType, IndexType>* row_permutation,

        const ScaledPermutation<ValueType, IndexType>* column_permutation,

        bool invert, Dense* output) const;


    template <typename OutputType, typename IndexType>

    void row_gather_impl(const array<IndexType>* row_idxs,

                         Dense<OutputType>* row_collection) const;


    template <typename OutputType, typename IndexType>

    void row_gather_impl(const Dense<ValueType>* alpha,

                         const array<IndexType>* row_idxs,

                         const Dense<ValueType>* beta,

                         Dense<OutputType>* row_collection) const;


private:

    size_type stride_;

    array<value_type> values_;


    void add_scaled_identity_impl(const LinOp* a, const LinOp* b) override;

};


}  // namespace matrix


namespace detail {


template <typename ValueType>

struct temporary_clone_helper<matrix::Dense<ValueType>> {

    static std::unique_ptr<matrix::Dense<ValueType>> create(

        std::shared_ptr<const Executor> exec, matrix::Dense<ValueType>* ptr,

        bool copy_data)

    {

        if (copy_data) {

            return gko::clone(std::move(exec), ptr);

        } else {

            return matrix::Dense<ValueType>::create(exec, ptr->get_size());

        }

    }

};


}  // namespace detail


template <typename VecPtr>

std::unique_ptr<matrix::Dense<typename detail::pointee<VecPtr>::value_type>>


make_dense_view(VecPtr&& vector)

{

    using value_type = typename detail::pointee<VecPtr>::value_type;

    return matrix::Dense<value_type>::create_view_of(vector);

}


template <typename VecPtr>

std::unique_ptr<

    const matrix::Dense<typename detail::pointee<VecPtr>::value_type>>


make_const_dense_view(VecPtr&& vector)

{

    using value_type = typename detail::pointee<VecPtr>::value_type;

    return matrix::Dense<value_type>::create_const_view_of(vector);

}


template <typename Matrix, typename... TArgs>


std::unique_ptr<Matrix> initialize(

    size_type stride, std::initializer_list<typename Matrix::value_type> vals,

    std::shared_ptr<const Executor> exec, TArgs&&... create_args)

{

    using dense = matrix::Dense<typename Matrix::value_type>;

    size_type num_rows = vals.size();

    auto tmp = dense::create(exec->get_master(), dim<2>{num_rows, 1}, stride);

    size_type idx = 0;

    for (const auto& elem : vals) {

        tmp->at(idx) = elem;

        ++idx;

    }

    auto mtx = Matrix::create(exec, std::forward<TArgs>(create_args)...);

    tmp->move_to(mtx);

    return mtx;

}


template <typename Matrix, typename... TArgs>


std::unique_ptr<Matrix> initialize(

    std::initializer_list<typename Matrix::value_type> vals,

    std::shared_ptr<const Executor> exec, TArgs&&... create_args)

{

    return initialize<Matrix>(1, vals, std::move(exec),

                              std::forward<TArgs>(create_args)...);

}


template <typename Matrix, typename... TArgs>


std::unique_ptr<Matrix> initialize(

    size_type stride,

    std::initializer_list<std::initializer_list<typename Matrix::value_type>>

        vals,

    std::shared_ptr<const Executor> exec, TArgs&&... create_args)

{

    using dense = matrix::Dense<typename Matrix::value_type>;

    size_type num_rows = vals.size();

    size_type num_cols = num_rows > 0 ? begin(vals)->size() : 1;

    auto tmp =

        dense::create(exec->get_master(), dim<2>{num_rows, num_cols}, stride);

    size_type ridx = 0;

    for (const auto& row : vals) {

        size_type cidx = 0;

        for (const auto& elem : row) {

            tmp->at(ridx, cidx) = elem;

            ++cidx;

        }

        ++ridx;

    }

    auto mtx = Matrix::create(exec, std::forward<TArgs>(create_args)...);

    tmp->move_to(mtx);

    return mtx;

}


template <typename Matrix, typename... TArgs>


std::unique_ptr<Matrix> initialize(

    std::initializer_list<std::initializer_list<typename Matrix::value_type>>

        vals,

    std::shared_ptr<const Executor> exec, TArgs&&... create_args)

{

    return initialize<Matrix>(vals.size() > 0 ? begin(vals)->size() : 0, vals,

                              std::move(exec),

                              std::forward<TArgs>(create_args)...);

}


}  // namespace gko


#endif  // GKO_PUBLIC_CORE_MATRIX_DENSE_HPP_

gko::DiagonalExtractable
The diagonal of a LinOp implementing this interface can be extracted.
Definition lin_op.hpp:743

gko::EnableAbsoluteComputation
The EnableAbsoluteComputation mixin provides the default implementations of compute_absolute_linop an...
Definition lin_op.hpp:794

gko::EnableLinOp
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:879

gko::EnablePolymorphicObject
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:668

gko::Executor
The first step in using the Ginkgo library consists of creating an executor.
Definition executor.hpp:615

gko::LinOp
Definition lin_op.hpp:117

gko::Permutable
Linear operators which support permutation should implement the Permutable interface.
Definition lin_op.hpp:484

gko::ReadableFromMatrixData
A LinOp implementing this interface can read its data from a matrix_data structure.
Definition lin_op.hpp:605

gko::ScaledIdentityAddable
Adds the operation M <- a I + b M for matrix M, identity operator I and scalars a and b,...
Definition lin_op.hpp:818

gko::Transposable
Linear operators which support transposition should implement the Transposable interface.
Definition lin_op.hpp:433

gko::WritableToMatrixData
A LinOp implementing this interface can write its data to a matrix_data structure.
Definition lin_op.hpp:660

gko::array
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:166

gko::device_matrix_data
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:36

gko::experimental::distributed::Vector
Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage f...
Definition vector.hpp:77

gko::matrix::Coo
COO stores a matrix in the coordinate matrix format.
Definition coo.hpp:65

gko::matrix::Csr
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:126

gko::matrix::Dense
Dense is a matrix format which explicitly stores all values of the matrix.
Definition dense.hpp:120

gko::matrix::Dense::scale_permute
std::unique_ptr< Dense > scale_permute(ptr_param< const ScaledPermutation< value_type, int64 > > row_permutation, ptr_param< const ScaledPermutation< value_type, int64 > > column_permutation, bool invert=false) const

gko::matrix::Dense::at
value_type & at(size_type row, size_type col) noexcept
Returns a single element of the matrix.
Definition dense.hpp:902

gko::matrix::Dense::compute_norm1
void compute_norm1(ptr_param< LinOp > result) const
Computes the column-wise (L^1) norm of this matrix.

gko::matrix::Dense::compute_absolute
void compute_absolute(ptr_param< absolute_type > output) const
Writes the absolute values of this matrix into an existing matrix.

gko::matrix::Dense::compute_norm2
void compute_norm2(ptr_param< LinOp > result, array< char > &tmp) const
Computes the column-wise Euclidean (L^2) norm of this matrix.

gko::matrix::Dense::row_permute
std::unique_ptr< LinOp > row_permute(const array< int64 > *permutation_indices) const override
Returns a LinOp representing the row permutation of the Permutable object.

gko::matrix::Dense::create_with_config_of
static std::unique_ptr< Dense > create_with_config_of(ptr_param< const Dense > other)
Creates a Dense matrix with the same size and stride as another Dense matrix.
Definition dense.hpp:197

gko::matrix::Dense::permute
std::unique_ptr< Dense > permute(ptr_param< const Permutation< int64 > > row_permutation, ptr_param< const Permutation< int64 > > column_permutation, bool invert=false) const

gko::matrix::Dense::operator=
Dense & operator=(const Dense &)
Copy-assigns a Dense matrix.

gko::matrix::Dense::get_imag
void get_imag(ptr_param< real_type > result) const
Extracts the imaginary part of the original matrix into a given real matrix.

gko::matrix::Dense::row_permute
void row_permute(const array< int32 > *permutation_indices, ptr_param< Dense > output) const
Writes the row-permuted matrix into the given output matrix.

gko::matrix::Dense::get_real
void get_real(ptr_param< real_type > result) const
Extracts the real part of the original matrix into a given real matrix.

gko::matrix::Dense::column_permute
std::unique_ptr< LinOp > column_permute(const array< int64 > *permutation_indices) const override
Returns a LinOp representing the column permutation of the Permutable object.

gko::matrix::Dense::create_with_type_of
static std::unique_ptr< Dense > create_with_type_of(ptr_param< const Dense > other, std::shared_ptr< const Executor > exec, const dim< 2 > &size, const dim< 2 > &local_size, size_type stride)
Definition dense.hpp:252

gko::matrix::Dense::compute_dot
void compute_dot(ptr_param< const LinOp > b, ptr_param< LinOp > result) const
Computes the column-wise dot product of this matrix and b.

gko::matrix::Dense::sub_scaled
void sub_scaled(ptr_param< const LinOp > alpha, ptr_param< const LinOp > b)
Subtracts b scaled by alpha from the matrix (aka: BLAS axpy).

gko::matrix::Dense::permute
std::unique_ptr< Dense > permute(ptr_param< const Permutation< int64 > > permutation, permute_mode mode=permute_mode::symmetric) const

gko::matrix::Dense::permute
std::unique_ptr< LinOp > permute(const array< int64 > *permutation_indices) const override
Returns a LinOp representing the symmetric row and column permutation of the Permutable object.

gko::matrix::Dense::at
ValueType at(size_type idx) const noexcept
Returns a single element of the matrix.
Definition dense.hpp:937

gko::matrix::Dense::row_gather
std::unique_ptr< Dense > row_gather(const array< int64 > *gather_indices) const
Create a Dense matrix consisting of the given rows from this matrix.

gko::matrix::Dense::inverse_permute
std::unique_ptr< LinOp > inverse_permute(const array< int64 > *permutation_indices) const override
Returns a LinOp representing the symmetric inverse row and column permutation of the Permutable objec...

gko::matrix::Dense::permute
std::unique_ptr< Dense > permute(ptr_param< const Permutation< int32 > > row_permutation, ptr_param< const Permutation< int32 > > column_permutation, bool invert=false) const
Creates a non-symmetrically permuted copy  of this matrix  with the given row and column permutations...

gko::matrix::Dense::row_gather
void row_gather(const array< int32 > *gather_indices, ptr_param< LinOp > row_collection) const
Copies the given rows from this matrix into row_collection.

gko::matrix::Dense::column_permute
void column_permute(const array< int32 > *permutation_indices, ptr_param< Dense > output) const
Writes the column-permuted matrix into the given output matrix.

gko::matrix::Dense::inverse_row_permute
std::unique_ptr< LinOp > inverse_row_permute(const array< int32 > *permutation_indices) const override
Returns a LinOp representing the row permutation of the inverse permuted object.

gko::matrix::Dense::Dense
Dense(const Dense &)
Copy-constructs a Dense matrix.

gko::matrix::Dense::permute
std::unique_ptr< Dense > permute(ptr_param< const Permutation< int32 > > permutation, permute_mode mode=permute_mode::symmetric) const
Creates a permuted copy  of this matrix  with the given permutation .

gko::matrix::Dense::inverse_permute
void inverse_permute(const array< int64 > *permutation_indices, ptr_param< Dense > output) const

gko::matrix::Dense::compute_squared_norm2
void compute_squared_norm2(ptr_param< LinOp > result, array< char > &tmp) const
Computes the square of the column-wise Euclidean (L^2) norm of this matrix.

gko::matrix::Dense::create_with_type_of
static std::unique_ptr< Dense > create_with_type_of(ptr_param< const Dense > other, std::shared_ptr< const Executor > exec, const dim< 2 > &size=dim< 2 >{})
Creates a Dense matrix with the same type as another Dense matrix but on a different executor and wit...
Definition dense.hpp:218

gko::matrix::Dense::permute
void permute(const array< int64 > *permutation_indices, ptr_param< Dense > output) const

gko::matrix::Dense::scale
void scale(ptr_param< const LinOp > alpha)
Scales the matrix with a scalar (aka: BLAS scal).

gko::matrix::Dense::inverse_column_permute
std::unique_ptr< LinOp > inverse_column_permute(const array< int32 > *permutation_indices) const override
Returns a LinOp representing the row permutation of the inverse permuted object.

gko::matrix::Dense::conj_transpose
void conj_transpose(ptr_param< Dense > output) const
Writes the conjugate-transposed matrix into the given output matrix.

gko::matrix::Dense::create_submatrix
std::unique_ptr< Dense > create_submatrix(const span &rows, const span &columns)
Create a submatrix from the original matrix.
Definition dense.hpp:1146

gko::matrix::Dense::row_permute
void row_permute(const array< int64 > *permutation_indices, ptr_param< Dense > output) const

gko::matrix::Dense::permute
std::unique_ptr< LinOp > permute(const array< int32 > *permutation_indices) const override
Returns a LinOp representing the symmetric row and column permutation of the Permutable object.

gko::matrix::Dense::create_submatrix
std::unique_ptr< Dense > create_submatrix(const span &rows, const span &columns, const size_type stride)
Create a submatrix from the original matrix.
Definition dense.hpp:1133

gko::matrix::Dense::compute_squared_norm2
void compute_squared_norm2(ptr_param< LinOp > result) const
Computes the square of the column-wise Euclidean (L^2) norm of this matrix.

gko::matrix::Dense::row_permute
std::unique_ptr< LinOp > row_permute(const array< int32 > *permutation_indices) const override
Returns a LinOp representing the row permutation of the Permutable object.

gko::matrix::Dense::permute
void permute(ptr_param< const Permutation< int64 > > permutation, ptr_param< Dense > output, permute_mode mode) const

gko::matrix::Dense::inverse_permute
void inverse_permute(const array< int32 > *permutation_indices, ptr_param< Dense > output) const
Writes the inverse symmetrically permuted matrix into the given output matrix.

gko::matrix::Dense::row_gather
std::unique_ptr< Dense > row_gather(const array< int32 > *gather_indices) const
Create a Dense matrix consisting of the given rows from this matrix.

gko::matrix::Dense::extract_diagonal
void extract_diagonal(ptr_param< Diagonal< ValueType > > output) const
Writes the diagonal of this matrix into an existing diagonal matrix.

gko::matrix::Dense::make_complex
void make_complex(ptr_param< complex_type > result) const
Writes a complex copy of the original matrix to a given complex matrix.

gko::matrix::Dense::compute_absolute
std::unique_ptr< absolute_type > compute_absolute() const override
Gets the AbsoluteLinOp.

gko::matrix::Dense::scale_permute
void scale_permute(ptr_param< const ScaledPermutation< value_type, int32 > > row_permutation, ptr_param< const ScaledPermutation< value_type, int32 > > column_permutation, ptr_param< Dense > output, bool invert=false) const
Overload of scale_permute(ptr_param<const ScaledPermutation<value_type,int32>>, ptr_param<const Scale...

gko::matrix::Dense::permute
void permute(ptr_param< const Permutation< int32 > > permutation, ptr_param< Dense > output, permute_mode mode) const
Overload of permute(ptr_param<const Permutation<int32>>, permute_mode) that writes the permuted copy ...

gko::matrix::Dense::row_gather
void row_gather(ptr_param< const LinOp > alpha, const array< int32 > *gather_indices, ptr_param< const LinOp > beta, ptr_param< LinOp > row_collection) const
Copies the given rows from this matrix into row_collection with scaling.

gko::matrix::Dense::get_const_values
const value_type * get_const_values() const noexcept
Returns a pointer to the array of values of the matrix.
Definition dense.hpp:870

gko::matrix::Dense::get_num_stored_elements
size_type get_num_stored_elements() const noexcept
Returns the number of elements explicitly stored in the matrix.
Definition dense.hpp:887

gko::matrix::Dense::compute_mean
void compute_mean(ptr_param< LinOp > result, array< char > &tmp) const
Computes the column-wise arithmetic mean of this matrix.

gko::matrix::Dense::at
ValueType & at(size_type idx) noexcept
Returns a single element of the matrix.
Definition dense.hpp:929

gko::matrix::Dense::scale_permute
std::unique_ptr< Dense > scale_permute(ptr_param< const ScaledPermutation< value_type, int32 > > row_permutation, ptr_param< const ScaledPermutation< value_type, int32 > > column_permutation, bool invert=false) const
Creates a scaled and permuted copy of this matrix.

gko::matrix::Dense::scale_permute
void scale_permute(ptr_param< const ScaledPermutation< value_type, int64 > > row_permutation, ptr_param< const ScaledPermutation< value_type, int64 > > column_permutation, ptr_param< Dense > output, bool invert=false) const

gko::matrix::Dense::compute_conj_dot
void compute_conj_dot(ptr_param< const LinOp > b, ptr_param< LinOp > result, array< char > &tmp) const
Computes the column-wise dot product of conj(this matrix) and b.

gko::matrix::Dense::compute_mean
void compute_mean(ptr_param< LinOp > result) const
Computes the column-wise arithmetic mean of this matrix.

gko::matrix::Dense::create
static std::unique_ptr< Dense > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size, array< value_type > values, size_type stride)
Creates a Dense matrix from an already allocated (and initialized) array.

gko::matrix::Dense::get_stride
size_type get_stride() const noexcept
Returns the stride of the matrix.
Definition dense.hpp:880

gko::matrix::Dense::inverse_permute
std::unique_ptr< LinOp > inverse_permute(const array< int32 > *permutation_indices) const override
Returns a LinOp representing the symmetric inverse row and column permutation of the Permutable objec...

gko::matrix::Dense::permute
void permute(const array< int32 > *permutation_indices, ptr_param< Dense > output) const
Writes the symmetrically permuted matrix into the given output matrix.

gko::matrix::Dense::scale_permute
void scale_permute(ptr_param< const ScaledPermutation< value_type, int64 > > permutation, ptr_param< Dense > output, permute_mode mode) const

gko::matrix::Dense::inverse_row_permute
void inverse_row_permute(const array< int32 > *permutation_indices, ptr_param< Dense > output) const
Writes the inverse row-permuted matrix into the given output matrix.

gko::matrix::Dense::inverse_column_permute
void inverse_column_permute(const array< int32 > *permutation_indices, ptr_param< Dense > output) const
Writes the inverse column-permuted matrix into the given output matrix.

gko::matrix::Dense::add_scaled
void add_scaled(ptr_param< const LinOp > alpha, ptr_param< const LinOp > b)
Adds b scaled by alpha to the matrix (aka: BLAS axpy).

gko::matrix::Dense::inverse_column_permute
std::unique_ptr< LinOp > inverse_column_permute(const array< int64 > *permutation_indices) const override
Returns a LinOp representing the row permutation of the inverse permuted object.

gko::matrix::Dense::create_view_of
static std::unique_ptr< Dense > create_view_of(ptr_param< Dense > other)
Creates a Dense matrix, where the underlying array is a view of another Dense matrix' array.
Definition dense.hpp:268

gko::matrix::Dense::permute
void permute(ptr_param< const Permutation< int32 > > row_permutation, ptr_param< const Permutation< int32 > > column_permutation, ptr_param< Dense > output, bool invert=false) const
Overload of permute(ptr_param<const Permutation<int32>>, ptr_param<constPermutation<int32>>,...

gko::matrix::Dense::compute_norm1
void compute_norm1(ptr_param< LinOp > result, array< char > &tmp) const
Computes the column-wise (L^1) norm of this matrix.

gko::matrix::Dense::inverse_row_permute
std::unique_ptr< LinOp > inverse_row_permute(const array< int64 > *permutation_indices) const override
Returns a LinOp representing the row permutation of the inverse permuted object.

gko::matrix::Dense::scale_permute
std::unique_ptr< Dense > scale_permute(ptr_param< const ScaledPermutation< value_type, int32 > > permutation, permute_mode mode=permute_mode::symmetric) const
Creates a scaled and permuted copy of this matrix.

gko::matrix::Dense::transpose
void transpose(ptr_param< Dense > output) const
Writes the transposed matrix into the given output matrix.

gko::matrix::Dense::compute_conj_dot
void compute_conj_dot(ptr_param< const LinOp > b, ptr_param< LinOp > result) const
Computes the column-wise dot product of conj(this matrix) and b.

gko::matrix::Dense::get_real
std::unique_ptr< real_type > get_real() const
Creates a new real matrix and extracts the real part of the original matrix into that.

gko::matrix::Dense::scale_permute
std::unique_ptr< Dense > scale_permute(ptr_param< const ScaledPermutation< value_type, int64 > > permutation, permute_mode mode=permute_mode::symmetric) const

gko::matrix::Dense::create_const_view_of
static std::unique_ptr< const Dense > create_const_view_of(ptr_param< const Dense > other)
Creates a immutable Dense matrix, where the underlying array is a view of another Dense matrix' array...
Definition dense.hpp:280

gko::matrix::Dense::conj_transpose
std::unique_ptr< LinOp > conj_transpose() const override
Returns a LinOp representing the conjugate transpose of the Transposable object.

gko::matrix::Dense::column_permute
std::unique_ptr< LinOp > column_permute(const array< int32 > *permutation_indices) const override
Returns a LinOp representing the column permutation of the Permutable object.

gko::matrix::Dense::transpose
std::unique_ptr< LinOp > transpose() const override
Returns a LinOp representing the transpose of the Transposable object.

gko::matrix::Dense::scale_permute
void scale_permute(ptr_param< const ScaledPermutation< value_type, int32 > > permutation, ptr_param< Dense > output, permute_mode mode) const
Overload of scale_permute(ptr_param<const ScaledPermutation<value_type,int32>>, permute_mode) that wr...

gko::matrix::Dense::compute_absolute_inplace
void compute_absolute_inplace() override
Compute absolute inplace on each element.

gko::matrix::Dense::create_submatrix
std::unique_ptr< Dense > create_submatrix(const local_span &rows, const local_span &columns, dim< 2 > size)
Create a submatrix from the original matrix.
Definition dense.hpp:1161

gko::matrix::Dense::make_complex
std::unique_ptr< complex_type > make_complex() const
Creates a complex copy of the original matrix.

gko::matrix::Dense::create_real_view
std::unique_ptr< const real_type > create_real_view() const
Create a real view of the (potentially) complex original matrix.

gko::matrix::Dense::column_permute
void column_permute(const array< int64 > *permutation_indices, ptr_param< Dense > output) const

gko::matrix::Dense::Dense
Dense(Dense &&)
Move-constructs a Dense matrix.

gko::matrix::Dense::inverse_row_permute
void inverse_row_permute(const array< int64 > *permutation_indices, ptr_param< Dense > output) const

gko::matrix::Dense::at
value_type at(size_type row, size_type col) const noexcept
Returns a single element of the matrix.
Definition dense.hpp:910

gko::matrix::Dense::create
static std::unique_ptr< Dense > create(std::shared_ptr< const Executor > exec, const dim< 2 > &size={}, size_type stride=0)
Creates an uninitialized Dense matrix of the specified size.

gko::matrix::Dense::create_const
static std::unique_ptr< const Dense > create_const(std::shared_ptr< const Executor > exec, const dim< 2 > &size, gko::detail::const_array_view< ValueType > &&values, size_type stride)
Creates a constant (immutable) Dense matrix from a constant array.

gko::matrix::Dense::permute
void permute(ptr_param< const Permutation< int64 > > row_permutation, ptr_param< const Permutation< int64 > > column_permutation, ptr_param< Dense > output, bool invert=false) const

gko::matrix::Dense::inv_scale
void inv_scale(ptr_param< const LinOp > alpha)
Scales the matrix with the inverse of a scalar.

gko::matrix::Dense::operator=
Dense & operator=(Dense &&)
Move-assigns a Dense matrix.

gko::matrix::Dense::get_values
value_type * get_values() noexcept
Returns a pointer to the array of values of the matrix.
Definition dense.hpp:861

gko::matrix::Dense::inverse_column_permute
void inverse_column_permute(const array< int64 > *permutation_indices, ptr_param< Dense > output) const

gko::matrix::Dense::compute_norm2
void compute_norm2(ptr_param< LinOp > result) const
Computes the column-wise Euclidean (L^2) norm of this matrix.

gko::matrix::Dense::row_gather
void row_gather(const array< int64 > *gather_indices, ptr_param< LinOp > row_collection) const

gko::matrix::Dense::get_imag
std::unique_ptr< real_type > get_imag() const
Creates a new real matrix and extracts the imaginary part of the original matrix into that.

gko::matrix::Dense::create_with_type_of
static std::unique_ptr< Dense > create_with_type_of(ptr_param< const Dense > other, std::shared_ptr< const Executor > exec, const dim< 2 > &size, size_type stride)
Definition dense.hpp:234

gko::matrix::Dense::create_real_view
std::unique_ptr< real_type > create_real_view()
Create a real view of the (potentially) complex original matrix.

gko::matrix::Dense::extract_diagonal
std::unique_ptr< Diagonal< ValueType > > extract_diagonal() const override
Extracts the diagonal entries of the matrix into a vector.

gko::matrix::Dense::fill
void fill(const ValueType value)
Fill the dense matrix with a given value.

gko::matrix::Dense::compute_dot
void compute_dot(ptr_param< const LinOp > b, ptr_param< LinOp > result, array< char > &tmp) const
Computes the column-wise dot product of this matrix and b.

gko::matrix::Dense::row_gather
void row_gather(ptr_param< const LinOp > alpha, const array< int64 > *gather_indices, ptr_param< const LinOp > beta, ptr_param< LinOp > row_collection) const

gko::matrix::Diagonal
This class is a utility which efficiently implements the diagonal matrix (a linear operator which sca...
Definition diagonal.hpp:56

gko::matrix::Ell
ELL is a matrix format where stride with explicit zeros is used such that all rows have the same numb...
Definition ell.hpp:66

gko::matrix::Fbcsr
Fixed-block compressed sparse row storage matrix format.
Definition fbcsr.hpp:116

gko::matrix::Hybrid
HYBRID is a matrix format which splits the matrix into ELLPACK and COO format.
Definition hybrid.hpp:57

gko::matrix::Permutation
Permutation is a matrix format that represents a permutation matrix, i.e.
Definition permutation.hpp:112

gko::matrix::ScaledPermutation
ScaledPermutation is a matrix combining a permutation with scaling factors.
Definition scaled_permutation.hpp:38

gko::matrix::Sellp
SELL-P is a matrix format similar to ELL format.
Definition sellp.hpp:58

gko::matrix::SparsityCsr
SparsityCsr is a matrix format which stores only the sparsity pattern of a sparse matrix by compressi...
Definition sparsity_csr.hpp:56

gko::ptr_param
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:41

gko::range
A range is a multidimensional view of the memory.
Definition range.hpp:304

gko::initialize
std::unique_ptr< Matrix > initialize(size_type stride, std::initializer_list< typename Matrix::value_type > vals, std::shared_ptr< const Executor > exec, TArgs &&... create_args)
Creates and initializes a column-vector.
Definition dense.hpp:1593

gko::experimental::distributed
The distributed namespace.
Definition polymorphic_object.hpp:19

gko::matrix
The matrix namespace.
Definition dense_cache.hpp:24

gko::matrix::permute_mode
permute_mode
Specifies how a permutation will be applied to a matrix.
Definition permutation.hpp:42

gko::matrix::permute_mode::columns
@ columns
The columns will be permuted.
Definition permutation.hpp:48

gko::matrix::permute_mode::rows
@ rows
The rows will be permuted.
Definition permutation.hpp:46

gko::matrix::permute_mode::symmetric
@ symmetric
The rows and columns will be permuted.
Definition permutation.hpp:53

gko
The Ginkgo namespace.
Definition abstract_factory.hpp:20

gko::remove_complex
typename detail::remove_complex_s< T >::type remove_complex
Obtain the type which removed the complex of complex/scalar type or the template parameter of class b...
Definition math.hpp:264

gko::int32
std::int32_t int32
32-bit signed integral type.
Definition types.hpp:107

gko::make_const_dense_view
std::unique_ptr< const matrix::Dense< typename detail::pointee< VecPtr >::value_type > > make_const_dense_view(VecPtr &&vector)
Creates a view of a given Dense vector.
Definition dense.hpp:1565

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

gko::make_const_array_view
detail::const_array_view< ValueType > make_const_array_view(std::shared_ptr< const Executor > exec, size_type size, const ValueType *data)
Helper function to create a const array view deducing the value type.
Definition array.hpp:820

gko::make_dense_view
std::unique_ptr< matrix::Dense< typename detail::pointee< VecPtr >::value_type > > make_dense_view(VecPtr &&vector)
Creates a view of a given Dense vector.
Definition dense.hpp:1548

gko::move_to
virtual void move_to(result_type *result)=0
Converts the implementer to an object of type result_type by moving data from this object.

gko::make_array_view
array< ValueType > make_array_view(std::shared_ptr< const Executor > exec, size_type size, ValueType *data)
Helper function to create an array view deducing the value type.
Definition array.hpp:801

gko::convert_to
virtual void convert_to(result_type *result) const =0
ConvertibleTo interface is used to mark that the implementer can be converted to the object of Result...

gko::int64
std::int64_t int64
64-bit signed integral type.
Definition types.hpp:113

gko::size_type
std::size_t size_type
Integral type used for allocation quantities.
Definition types.hpp:90

gko::clone
detail::cloned_type< Pointer > clone(const Pointer &p)
Creates a unique clone of the object pointed to by p.
Definition utils_helper.hpp:173

gko::read
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:160

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::next_precision
typename detail::find_precision_impl< T, step >::type next_precision
Obtains the next move type of T in the singly-linked precision corresponding bfloat16/half.
Definition math.hpp:466

gko::write
void write(StreamType &&os, MatrixPtrType &&matrix, layout_type layout=detail::mtx_io_traits< std::remove_cv_t< detail::pointee< MatrixPtrType > > >::default_layout)
Writes a matrix into an output stream in matrix market format.
Definition mtx_io.hpp:299

std
STL namespace.

gko::dim
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:26

gko::local_span
A span that is used exclusively for local numbering.
Definition range.hpp:138

gko::matrix_data
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:126

gko::span
A span is a lightweight structure used to create sub-ranges from other ranges.
Definition range.hpp:46