Implement convert_binsparse

Author: BenBrock

examples/convert_binsparse.cpp

@@ -0,0 +1,89 @@
+#include <binsparse/binsparse.hpp>
+#include <grb/grb.hpp>
+#include <iostream>
+#include <concepts>
+#include <complex>
+
+template <typename T, typename I>
+void convert(std::string input_file, std::string output_file, std::string format, std::string comment) {
+  if (format == "CSR") {
+    std::cout << "Reading in " << input_file << "...\n";
+    grb::matrix<T, I> x("mouse_gene.mtx");
+    binsparse::csr_matrix<T, I> matrix{x.backend_.values_.data(), x.backend_.colind_.data(), x.backend_.rowptr_.data(), x.shape()[0], x.shape()[1], I(x.size())};
+    binsparse::write_csr_matrix(output_file, matrix);
+    std::cout << "Writing to binsparse file " << output_file << " using " << format << " format...\n";
+  } else {
+    assert(false);
+    /*
+    std::cout << "Reading in " << input_file << "...\n";
+    grb::matrix<T, I, grb::coordinate> x("mouse_gene.mtx");
+    binsparse::coo_matrix<T, I> matrix{x.backend_.values_.data(), x.backend_.rowptr_.data(), x.backend_.colind_.data(), x.shape()[0], x.shape()[1], I(x.size())};
+    binsparse::write_coo_matrix(output_file, matrix);
+    std::cout << "Writing to binsparse file " << output_file << " using " << format << " format...\n";
+    */
+  }
+}
+
+template <typename I>
+void convert(std::string input_file, std::string output_file, std::string type,
+             std::string format, std::string comment) {
+  if (type == "real") {
+    convert<float, I>(input_file, output_file, format, comment);
+  } else if (type == "complex") {
+    assert(false);
+    // convert<std::complex<float>, I>(input_file, output_file, format, comment);
+  } else if (type == "integer") {
+    convert<int64_t, I>(input_file, output_file, format, comment);
+  } else if (type == "pattern") {
+    convert<bool, I>(input_file, output_file, format, comment);
+  }
+}
+
+
+int main(int argc, char** argv) {
+
+  if (argc < 3) {
+    std::cout << "usage: ./convert_binsparse [input_file.mtx] [output_file.hdf5] [optional: format {CSR, COO}]\n";
+    return 1;
+  }
+
+  std::string input_file(argv[1]);
+  std::string output_file(argv[2]);
+
+  std::string format;
+
+  if (argc >= 4) {
+    format = argv[3];
+
+    for (auto&& c : format) {
+      c = std::toupper(c);
+    }
+  } else {
+    format = "CSR";
+  }
+
+  auto [m, n, nnz, type, comment] = binsparse::mmread_metadata(input_file);
+
+  std::cout << "Matrix is " << m << " x " << n << " with " << nnz << " values.\n";
+  std::cout << "Type: " << type << std::endl;
+  std::cout << "Comment:\n";
+  std::cout << comment;
+
+  assert(format == "COO" || format == "CSR");
+
+  auto max_size = std::max({m, n, nnz});
+
+  if (max_size + 1 <= std::numeric_limits<uint8_t>::max()) {
+    convert<uint8_t>(input_file, output_file, type, format, comment);
+  } else if (max_size + 1 <= std::numeric_limits<uint16_t>::max()) {
+    convert<uint16_t>(input_file, output_file, type, format, comment);
+  } else if (max_size + 1 <= std::numeric_limits<uint32_t>::max()) {
+    convert<uint32_t>(input_file, output_file, type, format, comment);
+  } else if (max_size + 1 <= std::numeric_limits<uint64_t>::max()) {
+    convert<uint64_t>(input_file, output_file, type, format, comment);
+  } else {
+    throw std::runtime_error("Error! Matrix dimensions or NNZ too large to handle.");
+  }
+
+  return 0;
+}

include/binsparse/binsparse.hpp

@@ -4,10 +4,14 @@
 #include <nlohmann/json.hpp>
 #include <binsparse/containers/matrices.hpp>
 #include "hdf5_tools.hpp"
+#include "type_info.hpp"
 #include <memory>
 #include <type_traits>
 
 #include <binsparse/c_bindings/allocator_wrapper.hpp>
+#include <binsparse/matrix_market/matrix_market.hpp>
+
+#include <iostream>
 
 namespace binsparse {
 
@@ -27,16 +31,17 @@ void write_csr_matrix(std::string fname,
   hdf5_tools::write_dataset(f, "indices_1", colind);
   hdf5_tools::write_dataset(f, "pointers_to_1", row_ptr);
 
-  std::string json_string =
-  "{\n"
-  "  \"format\": \"CSR\",\n"
-  "  \"shape\": [";
-  json_string += std::to_string(m.m) + ", " + std::to_string(m.n) +
-  "],\n" +
-  "  \"nnz\": " + std::to_string(m.nnz) + "\n" +
-  "}\n";
+  using json = nlohmann::json;
+  json j;
+  j["binsparse"]["version"] = 0.5;
+  j["binsparse"]["format"] = "CSR";
+  j["binsparse"]["shape"] = {m.m, m.n};
+  j["binsparse"]["nnz"] = m.nnz;
+  j["binsparse"]["data_types"]["pointers_to_1"] = type_info<I>::label();
+  j["binsparse"]["data_types"]["indices_1"] = type_info<I>::label();
+  j["binsparse"]["data_types"]["values"] = type_info<T>::label();
 
-  hdf5_tools::write_dataset(f, "metadata", json_string);
+  hdf5_tools::write_dataset(f, "metadata", j.dump(2));
 
   f.close();
 }
@@ -50,10 +55,10 @@ csr_matrix<T, I> read_csr_matrix(std::string fname, Allocator&& alloc) {
   using json = nlohmann::json;
   auto data = json::parse(metadata);
 
-  if (data["format"] == "CSR") {
-    auto nrows = data["shape"][0];
-    auto ncols = data["shape"][1];
-    auto nnz = data["nnz"];
+  if (data["binsparse"]["format"] == "CSR") {
+    auto nrows = data["binsparse"]["shape"][0];
+    auto ncols = data["binsparse"]["shape"][1];
+    auto nnz = data["binsparse"]["nnz"];
 
     typename std::allocator_traits<std::remove_cvref_t<Allocator>>
        :: template rebind_alloc<I> i_alloc(alloc);
@@ -89,16 +94,17 @@ void write_coo_matrix(std::string fname,
   hdf5_tools::write_dataset(f, "indices_0", rowind);
   hdf5_tools::write_dataset(f, "indices_1", colind);
 
-  std::string json_string =
-  "{\n"
-  "  \"format\": \"COO\",\n"
-  "  \"shape\": [";
-  json_string += std::to_string(m.m) + ", " + std::to_string(m.n) +
-  "],\n" +
-  "  \"nnz\": " + std::to_string(m.nnz) + "\n" +
-  "}\n";
+  using json = nlohmann::json;
+  json j;
+  j["binsparse"]["version"] = 0.5;
+  j["binsparse"]["format"] = "COO";
+  j["binsparse"]["shape"] = {m.m, m.n};
+  j["binsparse"]["nnz"] = m.nnz;
+  j["binsparse"]["data_types"]["indices_0"] = type_info<I>::label();
+  j["binsparse"]["data_types"]["indices_1"] = type_info<I>::label();
+  j["binsparse"]["data_types"]["values"] = type_info<T>::label();
 
-  hdf5_tools::write_dataset(f, "metadata", json_string);
+  hdf5_tools::write_dataset(f, "metadata", j.dump(2));
 
   f.close();
 }
@@ -112,10 +118,10 @@ coo_matrix<T, I> read_coo_matrix(std::string fname, Allocator&& alloc) {
   using json = nlohmann::json;
   auto data = json::parse(metadata);
 
-  if (data["format"] == "COO") {
-    auto nrows = data["shape"][0];
-    auto ncols = data["shape"][1];
-    auto nnz = data["nnz"];
+  if (data["binsparse"]["format"] == "COO") {
+    auto nrows = data["binsparse"]["shape"][0];
+    auto ncols = data["binsparse"]["shape"][1];
+    auto nnz = data["binsparse"]["nnz"];
 
     typename std::allocator_traits<std::remove_cvref_t<Allocator>>
        :: template rebind_alloc<I> i_alloc(alloc);

include/binsparse/hdf5_tools.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cassert>
 #include <vector>
 #include <ranges>
 #include <H5Cpp.h>

include/binsparse/matrix_market/matrix_market.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+#include "matrix_market_inspector.hpp"

include/binsparse/matrix_market/matrix_market_inspector.hpp

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+namespace binsparse {
+
+// Read metadata from Matrix Market file.
+// Returns a tuple holding 5 values.
+// 0 - number of rows in matrix
+// 1 - number of columns in matrix
+// 2 - number of values in matrix
+// 3 - type of the matrix (real / integer / complex / pattern)
+// 4 - comments
+auto mmread_metadata(std::string file_path) {
+  std::string type;
+
+  std::ifstream f;
+
+  f.open(file_path.c_str());
+
+  if (!f.is_open()) {
+    // TODO better choice of exception.
+    throw std::runtime_error("mmread_metadata: cannot open " + file_path);
+  }
+
+  std::string buf;
+
+  // Read in first line.
+  std::getline(f, buf);
+  std::istringstream ss(buf);
+
+  std::string item;
+
+  // Check file is Matrix Market format.
+  ss >> item;
+  if (item != "%%MatrixMarket") {
+    throw std::runtime_error(file_path + " could not be parsed as a Matrix Market file.");
+  }
+
+  // Read in "matrix"
+  ss >> item;
+  if (item != "matrix") {
+    throw std::runtime_error(file_path + " could not be parsed as a Matrix Market file.");
+  }
+
+  // Read in coordinate / array
+  ss >> item;
+
+  // Read in type of matrix (real / integer / complex / pattern)
+  ss >> item;
+  type = item;
+
+  // Read in general / symmetric / skew-symmetric / Hermitian
+  ss >> item;
+
+  std::string comment;
+
+  bool outOfComments = false;
+  while (!outOfComments) {
+    std::getline(f, buf);
+
+    comment += buf + "\n";
+
+    if (buf[0] != '%') {
+      outOfComments = true;
+    }
+  }
+
+  std::size_t m, n, nnz;
+
+  ss.clear();
+  ss.str(buf);
+  ss >> m >> n >> nnz;
+
+  return std::tuple(m, n, nnz, type, comment);
+}
+
+} // end binsparse

include/binsparse/type_info.hpp

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <cassert>
+
+namespace binsparse {
+
+template <typename T>
+struct type_info;
+
+template <typename T>
+requires(std::is_const_v<T> || std::is_volatile_v<T>)
+struct type_info<T> {
+  static constexpr auto label() noexcept {
+    return type_info<std::remove_cv_t<T>>::label();
+  }
+};
+
+template <>
+struct type_info<uint8_t> {
+  static constexpr auto label() noexcept {
+    return "uint8";
+  }
+};
+
+template <>
+struct type_info<uint16_t> {
+  static constexpr auto label() noexcept {
+    return "uint16";
+  }
+};
+
+template <>
+struct type_info<uint32_t> {
+  static constexpr auto label() noexcept {
+    return "uint32";
+  }
+};
+
+template <>
+struct type_info<uint64_t> {
+  static constexpr auto label() noexcept {
+    return "uint64";
+  }
+};
+
+template <>
+struct type_info<std::size_t> {
+  static constexpr auto label() noexcept {
+    return "uint64";
+  }
+};
+
+template <>
+struct type_info<int8_t> {
+  static constexpr auto label() noexcept {
+    return "int8";
+  }
+};
+
+template <>
+struct type_info<int16_t> {
+  static constexpr auto label() noexcept {
+    return "int16";
+  }
+};
+
+template <>
+struct type_info<int32_t> {
+  static constexpr auto label() noexcept {
+    return "int32";
+  }
+};
+
+template <>
+struct type_info<int64_t> {
+  static constexpr auto label() noexcept {
+    return "int64";
+  }
+};
+
+template <>
+struct type_info<float> {
+  static constexpr auto label() noexcept {
+    return "float32";
+  }
+};
+
+template <>
+struct type_info<double> {
+  static constexpr auto label() noexcept {
+    return "float64";
+  }
+};
+
+template <>
+struct type_info<bool> {
+  static constexpr auto label() noexcept {
+    return "bint8";
+  }
+};
+
+} // end binsparse