batch_csr.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_MATRIX_BATCH_CSR_HPP_
#define GKO_PUBLIC_CORE_MATRIX_BATCH_CSR_HPP_
 
 
#include <initializer_list>
#include <vector>
 
 
#include <ginkgo/core/base/array.hpp>
#include <ginkgo/core/base/batch_lin_op.hpp>
#include <ginkgo/core/base/batch_multi_vector.hpp>
#include <ginkgo/core/base/executor.hpp>
#include <ginkgo/core/base/mtx_io.hpp>
#include <ginkgo/core/base/types.hpp>
#include <ginkgo/core/base/utils.hpp>
#include <ginkgo/core/matrix/csr.hpp>
 
 
namespace gko {
namespace batch {
namespace matrix {
 
 
template <typename ValueType = default_precision, typename IndexType = int32>
class Csr final
    : public EnableBatchLinOp<Csr<ValueType, IndexType>>,
      public ConvertibleTo<Csr<next_precision<ValueType>, IndexType>> {
    friend class EnablePolymorphicObject<Csr, BatchLinOp>;
    friend class Csr<to_complex<ValueType>, IndexType>;
    friend class Csr<next_precision<ValueType>, IndexType>;
    static_assert(std::is_same<IndexType, int32>::value,
                  "IndexType must be a 32 bit integer");
 
public:
    using EnableBatchLinOp<Csr>::convert_to;
    using EnableBatchLinOp<Csr>::move_to;
 
    using value_type = ValueType;
    using index_type = IndexType;
    using unbatch_type = gko::matrix::Csr<value_type, index_type>;
    using absolute_type = remove_complex<Csr>;
    using complex_type = to_complex<Csr>;
 
    void convert_to(
        Csr<next_precision<ValueType>, IndexType>* result) const override;
 
    void move_to(Csr<next_precision<ValueType>, IndexType>* result) override;
 
    std::unique_ptr<unbatch_type> create_view_for_item(size_type item_id);
 
    std::unique_ptr<const unbatch_type> create_const_view_for_item(
        size_type item_id) const;
 
    value_type* get_values() noexcept { return values_.get_data(); }
 
    const value_type* get_const_values() const noexcept
    {
        return values_.get_const_data();
    }
 
    index_type* get_col_idxs() noexcept { return col_idxs_.get_data(); }
 
    const index_type* get_const_col_idxs() const noexcept
    {
        return col_idxs_.get_const_data();
    }
 
    index_type* get_row_ptrs() noexcept { return row_ptrs_.get_data(); }
 
    const index_type* get_const_row_ptrs() const noexcept
    {
        return row_ptrs_.get_const_data();
    }
 
    size_type get_num_stored_elements() const noexcept
    {
        return values_.get_size();
    }
 
    size_type get_num_elements_per_item() const noexcept
    {
        return this->get_num_stored_elements() / this->get_num_batch_items();
    }
 
    value_type* get_values_for_item(size_type batch_id) noexcept
    {
        GKO_ASSERT(batch_id < this->get_num_batch_items());
        GKO_ASSERT(values_.get_size() >=
                   batch_id * this->get_num_elements_per_item());
        return values_.get_data() +
               batch_id * this->get_num_elements_per_item();
    }
 
    const value_type* get_const_values_for_item(
        size_type batch_id) const noexcept
    {
        GKO_ASSERT(batch_id < this->get_num_batch_items());
        GKO_ASSERT(values_.get_size() >=
                   batch_id * this->get_num_elements_per_item());
        return values_.get_const_data() +
               batch_id * this->get_num_elements_per_item();
    }
 
    static std::unique_ptr<Csr> create(
        std::shared_ptr<const Executor> exec,
        const batch_dim<2>& size = batch_dim<2>{},
        size_type num_nonzeros_per_item = {});
 
    static std::unique_ptr<Csr> create(std::shared_ptr<const Executor> exec,
                                       const batch_dim<2>& size,
                                       array<value_type> values,
                                       array<index_type> col_idxs,
                                       array<index_type> row_ptrs);
 
    template <typename InputValueType, typename ColIndexType,
              typename RowPtrType>
    GKO_DEPRECATED(
        "explicitly construct the gko::array arguments instead of passing "
        "initializer lists")
    static std::unique_ptr<Csr> create(
        std::shared_ptr<const Executor> exec, const batch_dim<2>& size,
        std::initializer_list<InputValueType> values,
        std::initializer_list<ColIndexType> col_idxs,
        std::initializer_list<RowPtrType> row_ptrs)
    {
        return create(exec, size, array<value_type>{exec, std::move(values)},
                      array<index_type>{exec, std::move(col_idxs)},
                      array<index_type>{exec, std::move(row_ptrs)});
    }
 
    static std::unique_ptr<const Csr> create_const(
        std::shared_ptr<const Executor> exec, const batch_dim<2>& sizes,
        gko::detail::const_array_view<value_type>&& values,
        gko::detail::const_array_view<index_type>&& col_idxs,
        gko::detail::const_array_view<index_type>&& row_ptrs);
 
    Csr* apply(ptr_param<const MultiVector<value_type>> b,
               ptr_param<MultiVector<value_type>> x);
 
    Csr* apply(ptr_param<const MultiVector<value_type>> alpha,
               ptr_param<const MultiVector<value_type>> b,
               ptr_param<const MultiVector<value_type>> beta,
               ptr_param<MultiVector<value_type>> x);
 
    const Csr* apply(ptr_param<const MultiVector<value_type>> b,
                     ptr_param<MultiVector<value_type>> x) const;
 
    const Csr* apply(ptr_param<const MultiVector<value_type>> alpha,
                     ptr_param<const MultiVector<value_type>> b,
                     ptr_param<const MultiVector<value_type>> beta,
                     ptr_param<MultiVector<value_type>> x) const;
 
    void scale(const array<value_type>& row_scale,
               const array<value_type>& col_scale);
 
    void add_scaled_identity(ptr_param<const MultiVector<value_type>> alpha,
                             ptr_param<const MultiVector<value_type>> beta);
 
private:
    Csr(std::shared_ptr<const Executor> exec,
        const batch_dim<2>& size = batch_dim<2>{},
        size_type num_nonzeros_per_item = {});
 
    Csr(std::shared_ptr<const Executor> exec, const batch_dim<2>& size,
        array<value_type> values, array<index_type> col_idxs,
        array<index_type> row_ptrs)
        : EnableBatchLinOp<Csr>(exec, size),
          values_{exec, std::move(values)},
          col_idxs_{exec, std::move(col_idxs)},
          row_ptrs_{exec, std::move(row_ptrs)}
    {
        // Ensure that the value and col_idxs arrays have the correct size
        auto max_num_elems = this->get_common_size()[0] *
                             this->get_common_size()[1] *
                             this->get_num_batch_items();
        GKO_ASSERT(values_.get_size() <= max_num_elems);
        GKO_ASSERT_EQ(row_ptrs_.get_size(), this->get_common_size()[0] + 1);
        GKO_ASSERT_EQ(this->get_num_elements_per_item(), col_idxs_.get_size());
    }
 
    void apply_impl(const MultiVector<value_type>* b,
                    MultiVector<value_type>* x) const;
 
    void apply_impl(const MultiVector<value_type>* alpha,
                    const MultiVector<value_type>* b,
                    const MultiVector<value_type>* beta,
                    MultiVector<value_type>* x) const;
 
    array<value_type> values_;
    array<index_type> col_idxs_;
    array<index_type> row_ptrs_;
};
 
 
}  // namespace matrix
}  // namespace batch
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_MATRIX_BATCH_CSR_HPP_