mtx_io.hpp

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_MTX_IO_HPP_
#define GKO_PUBLIC_CORE_BASE_MTX_IO_HPP_
 
 
#include <istream>
 
#include <ginkgo/core/base/matrix_data.hpp>
#include <ginkgo/core/base/utils_helper.hpp>
 
 
namespace gko {
 

template <typename ValueType = default_precision, typename IndexType = int32>
matrix_data<ValueType, IndexType> read_raw(std::istream& is);
 

template <typename ValueType = default_precision, typename IndexType = int32>
matrix_data<ValueType, IndexType> read_binary_raw(std::istream& is);
 

template <typename ValueType = default_precision, typename IndexType = int32>
matrix_data<ValueType, IndexType> read_generic_raw(std::istream& is);
 

enum class layout_type {
    array,
    coordinate
};
 

template <typename ValueType, typename IndexType>
void write_raw(std::ostream& os, const matrix_data<ValueType, IndexType>& data,
               layout_type layout = layout_type::coordinate);
 

template <typename ValueType, typename IndexType>
void write_binary_raw(std::ostream& os,
                      const matrix_data<ValueType, IndexType>& data);
 

template <typename MatrixType, typename StreamType, typename... MatrixArgs>
inline std::unique_ptr<MatrixType> read(StreamType&& is, MatrixArgs&&... args)
{
    auto mtx = MatrixType::create(std::forward<MatrixArgs>(args)...);
    mtx->read(read_raw<typename MatrixType::value_type,
                       typename MatrixType::index_type>(is));
    return mtx;
}
 

template <typename MatrixType, typename StreamType, typename... MatrixArgs>
inline std::unique_ptr<MatrixType> read_binary(StreamType&& is,
                                               MatrixArgs&&... args)
{
    auto mtx = MatrixType::create(std::forward<MatrixArgs>(args)...);
    mtx->read(read_binary_raw<typename MatrixType::value_type,
                              typename MatrixType::index_type>(is));
    return mtx;
}
 

template <typename MatrixType, typename StreamType, typename... MatrixArgs>
inline std::unique_ptr<MatrixType> read_generic(StreamType&& is,
                                                MatrixArgs&&... args)
{
    auto mtx = MatrixType::create(std::forward<MatrixArgs>(args)...);
    mtx->read(read_generic_raw<typename MatrixType::value_type,
                               typename MatrixType::index_type>(is));
    return mtx;
}
 
 
namespace matrix {
 
 
template <typename ValueType>
class Dense;
 
 
class Fft;
 
 
class Fft2;
 
 
class Fft3;
 
 
}  // namespace matrix
 
 
namespace detail {
 

template <typename MatrixType>
struct mtx_io_traits {
    static constexpr auto default_layout = layout_type::coordinate;
};
 
 
template <typename ValueType>
struct mtx_io_traits<gko::matrix::Dense<ValueType>> {
    static constexpr auto default_layout = layout_type::array;
};
 
 
template <>
struct mtx_io_traits<gko::matrix::Fft> {
    static constexpr auto default_layout = layout_type::array;
};
 
 
template <>
struct mtx_io_traits<gko::matrix::Fft2> {
    static constexpr auto default_layout = layout_type::array;
};
 
 
template <>
struct mtx_io_traits<gko::matrix::Fft3> {
    static constexpr auto default_layout = layout_type::array;
};
 
 
}  // namespace detail
 

template <
    typename MatrixPtrType, typename StreamType,
    std::enable_if_t<!std::is_same_v<
        std::remove_cv_t<detail::pointee<MatrixPtrType>>, LinOp>>* = nullptr>
inline void write(
    StreamType&& os, MatrixPtrType&& matrix,
    layout_type layout = detail::mtx_io_traits<
        std::remove_cv_t<detail::pointee<MatrixPtrType>>>::default_layout)
{
    using MatrixType = detail::pointee<MatrixPtrType>;
    matrix_data<typename MatrixType::value_type,
                typename MatrixType::index_type>
        data{};
    matrix->write(data);
    write_raw(os, data, layout);
}

void write(std::ostream& os, ptr_param<const LinOp> matrix);
 

template <typename MatrixPtrType, typename StreamType>
inline void write_binary(StreamType&& os, MatrixPtrType&& matrix)
{
    using MatrixType = detail::pointee<MatrixPtrType>;
    matrix_data<typename MatrixType::value_type,
                typename MatrixType::index_type>
        data{};
    matrix->write(data);
    write_binary_raw(os, data);
}
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_MTX_IO_HPP_