device_views.hpp

// SPDX-FileCopyrightText: 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_MATRIX_DEVICE_DENSE_HPP_
#define GKO_PUBLIC_CORE_MATRIX_DEVICE_DENSE_HPP_
 
#include <cassert>
 
#include <ginkgo/core/base/dim.hpp>
 
 
namespace gko {
namespace matrix {
namespace view {
 
 
template <typename ValueType>
struct dense {
    dim<2> size;
    size_type stride;
    ValueType* values;
 
    constexpr dense(dim<2> size, size_type stride, ValueType* values)
        : size{size}, stride{stride}, values{values}
    {
        assert(stride >= size[1]);
    }
 
    constexpr dense<const ValueType> as_const() const
    {
        return dense<const ValueType>{size, stride, values};
    }
 
    constexpr ValueType& operator()(size_type row, size_type col) const
    {
        assert(row < size[0] && col < size[1]);
        return values[row * stride + col];
    }
};
 
 
template <typename ValueType, typename IndexType>
struct coo {
    dim<2> size;
    size_type num_stored_elements;
    ValueType* values;
    IndexType* row_idxs;
    IndexType* col_idxs;
 
    constexpr coo(dim<2> size, size_type num_stored_elements, ValueType* values,
                  IndexType* row_idxs, IndexType* col_idxs)
        : size{size},
          num_stored_elements{num_stored_elements},
          values{values},
          row_idxs{row_idxs},
          col_idxs{col_idxs}
    {}
 
    constexpr coo<const ValueType, const IndexType> as_const() const
    {
        return coo<const ValueType, const IndexType>{
            size, num_stored_elements, values, row_idxs, col_idxs};
    }
};
 
 
template <typename ValueType, typename IndexType>
struct ell {
    dim<2> size;
    size_type num_stored_elements_per_row;
    size_type stride;
    ValueType* values;
    IndexType* col_idxs;
 
    constexpr ell(dim<2> size, size_type num_stored_elements_per_row,
                  size_type stride, ValueType* values, IndexType* col_idxs)
        : size{size},
          num_stored_elements_per_row{num_stored_elements_per_row},
          stride{stride},
          values{values},
          col_idxs(col_idxs)
    {
        assert(stride >= size[0]);
    }
 
    constexpr ell<const ValueType, const IndexType> as_const() const
    {
        return ell<const ValueType, const IndexType>{
            size, num_stored_elements_per_row, stride, values, col_idxs};
    }
 
    constexpr ValueType& val_at(size_type row, size_type idx) const
    {
        return values[this->linearize_index(row, idx)];
    }
 
    constexpr IndexType& col_at(size_type row, size_type idx) const
    {
        return col_idxs[this->linearize_index(row, idx)];
    }
 
private:
    constexpr size_type linearize_index(size_type row,
                                        size_type idx) const noexcept
    {
        assert(idx < num_stored_elements_per_row && row < size[0]);
        return row + stride * idx;
    }
};
 
 
}  // namespace view
}  // namespace matrix
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_MATRIX_DEVICE_DENSE_HPP_