load_compressed_sparse_matrix.hpp

Go to the documentation of this file.

#ifndef TATAMI_HDF5_LOAD_SPARSE_MATRIX_HPP
#define TATAMI_HDF5_LOAD_SPARSE_MATRIX_HPP
 
#include "H5Cpp.h"
 
#include <string>
 
#include "tatami/tatami.hpp"
#include "utils.hpp"
 
namespace tatami_hdf5 {
 
template<typename Value_, typename Index_, class ValueStorage_ = std::vector<Value_>, class IndexStorage_ = std::vector<Index_>, class PointerStorage_ = std::vector<size_t> >
std::shared_ptr<tatami::Matrix<Value_, Index_> > load_compressed_sparse_matrix(
    size_t nr, 
    size_t nc, 
    const std::string& file, 
    const std::string& vals, 
    const std::string& idx, 
    const std::string& ptr,
    bool row) 
{
    H5::H5File file_handle(file, H5F_ACC_RDONLY);
 
    auto dhandle = open_and_check_dataset<false>(file_handle, vals);
    const size_t nonzeros = get_array_dimensions<1>(dhandle, "vals")[0];
 
    ValueStorage_ x(nonzeros);
    dhandle.read(x.data(), define_mem_type<tatami::ElementType<ValueStorage_> >());
    
    auto ihandle = open_and_check_dataset<true>(file_handle, idx);
    if (get_array_dimensions<1>(ihandle, "idx")[0] != nonzeros) {
        throw std::runtime_error("number of non-zero elements is not consistent between 'data' and 'idx'");
    }
    IndexStorage_ i(nonzeros);
    ihandle.read(i.data(), define_mem_type<tatami::ElementType<IndexStorage_> >());
 
    auto phandle = open_and_check_dataset<true>(file_handle, ptr);
    const size_t ptr_size = get_array_dimensions<1>(phandle, "ptr")[0];
    if (ptr_size != (row ? nr : nc) + 1) {
        throw std::runtime_error("'ptr' dataset should have length equal to the number of " + (row ? std::string("rows") : std::string("columns")) + " plus 1");
    }
 
    // Because HDF5 doesn't have a native type for size_t.
    PointerStorage_ p(ptr_size);
    if constexpr(std::is_same<size_t, tatami::ElementType<PointerStorage_> >::value) {
        if constexpr(std::is_same<size_t, hsize_t>::value) {
            phandle.read(p.data(), H5::PredType::NATIVE_HSIZE);
        } else {
            std::vector<hsize_t> p0(ptr_size);
            phandle.read(p0.data(), H5::PredType::NATIVE_HSIZE);
            std::copy(p0.begin(), p0.end(), p.begin());
        }
    } else {
        phandle.read(p.data(), define_mem_type<tatami::ElementType<PointerStorage_> >());
    }
 
    return std::make_shared<tatami::CompressedSparseMatrix<Value_, Index_, ValueStorage_, IndexStorage_, PointerStorage_> >(nr, nc, std::move(x), std::move(i), std::move(p), row);
}
 
}
 
#endif