Add clang-format

Author: BenBrock

.clang-format

@@ -0,0 +1,5 @@
+---
+BasedOnStyle: LLVM
+PointerAlignment: Left
+ColumnLimit: 80
+---

.pre-commit-config.yaml

@@ -0,0 +1,14 @@
+repos:
+
+- repo: https://github.com/pre-commit/mirrors-clang-format
+  rev: v16.0.6
+  hooks:
+    - id: clang-format
+
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v4.4.0
+  hooks:
+    - id: trailing-whitespace
+    - id: end-of-file-fixer
+    - id: mixed-line-ending
+    - id: check-added-large-files

README.md

@@ -101,4 +101,4 @@ bbrock@FVFJ21QKQ6LWmac:~/src/binsparse-reference-impl/build/examples$ make -j
 [100%] Linking CXX executable convert_binsparse
 [100%] Built target convert_binsparse
 bbrock@mymac:~/src/binsparse-reference-impl/build/examples$
-```
+```

examples/CMakeLists.txt

@@ -6,4 +6,3 @@ endfunction()
 add_example(test)
 add_example(convert_binsparse)
 add_example(inspect_binsparse)
-

examples/Makefile

@@ -13,7 +13,7 @@ BINSPARSE_DIR ?= ../include
 # HDF5 library location
 HDF5_DIR ?= /opt/homebrew/Cellar/hdf5/1.14.2
 HDF5_CXXFLAGS ?= -I$(HDF5_DIR)/include
-HDF5_LIBRARY_FLAGS ?= -L$(HDF5_DIR)/lib -lhdf5_hl_cpp -lhdf5_cpp -lhdf5_hl -lhdf5 
+HDF5_LIBRARY_FLAGS ?= -L$(HDF5_DIR)/lib -lhdf5_hl_cpp -lhdf5_cpp -lhdf5_hl -lhdf5
 
 # = = = = = = = = = = = = = = = = = = = = = = = = = = = #
 

examples/convert_binsparse.cpp

@@ -1,46 +1,57 @@
 #include <binsparse/binsparse.hpp>
-#include <iostream>
-#include <concepts>
 #include <complex>
+#include <concepts>
+#include <iostream>
 
 template <typename T, typename I>
-void convert_to_binsparse(std::string input_file, std::string output_file, std::string format, std::string comment) {
+void convert_to_binsparse(std::string input_file, std::string output_file,
+                          std::string format, std::string comment) {
   nlohmann::json user_keys;
   user_keys["comment"] = comment;
   if (format == "CSR") {
     std::cout << "Reading in " << input_file << "...\n";
-    auto x = binsparse::__detail::mmread<T, I, binsparse::__detail::csr_matrix_owning<T, I>>(input_file);
-    binsparse::csr_matrix<T, I> matrix{x.values().data(), x.colind().data(), x.rowptr().data(), std::get<0>(x.shape()), std::get<1>(x.shape()), I(x.size())};
+    auto x = binsparse::__detail::mmread<
+        T, I, binsparse::__detail::csr_matrix_owning<T, I>>(input_file);
+    binsparse::csr_matrix<T, I> matrix{
+        x.values().data(),      x.colind().data(),      x.rowptr().data(),
+        std::get<0>(x.shape()), std::get<1>(x.shape()), I(x.size())};
     binsparse::write_csr_matrix(output_file, matrix, user_keys);
-    std::cout << "Writing to binsparse file " << output_file << " using " << format << " format...\n";
+    std::cout << "Writing to binsparse file " << output_file << " using "
+              << format << " format...\n";
   } else {
-    auto x = binsparse::__detail::mmread<T, I, binsparse::__detail::coo_matrix_owning<T, I>>(input_file);
-    binsparse::coo_matrix<T, I> matrix{x.values().data(), x.rowind().data(), x.colind().data(), std::get<0>(x.shape()), std::get<1>(x.shape()), I(x.size())};
+    auto x = binsparse::__detail::mmread<
+        T, I, binsparse::__detail::coo_matrix_owning<T, I>>(input_file);
+    binsparse::coo_matrix<T, I> matrix{
+        x.values().data(),      x.rowind().data(),      x.colind().data(),
+        std::get<0>(x.shape()), std::get<1>(x.shape()), I(x.size())};
     binsparse::write_coo_matrix(output_file, matrix, user_keys);
-    std::cout << "Writing to binsparse file " << output_file << " using " << format << " format...\n";
+    std::cout << "Writing to binsparse file " << output_file << " using "
+              << format << " format...\n";
   }
 }
 
 template <typename I>
-void convert_to_binsparse(std::string input_file, std::string output_file, std::string type,
-             std::string format, std::string comment) {
+void convert_to_binsparse(std::string input_file, std::string output_file,
+                          std::string type, std::string format,
+                          std::string comment) {
   if (type == "real") {
     convert_to_binsparse<float, I>(input_file, output_file, format, comment);
   } else if (type == "complex") {
     assert(false);
-    // convert_to_binsparse<std::complex<float>, I>(input_file, output_file, format, comment);
+    // convert_to_binsparse<std::complex<float>, I>(input_file, output_file,
+    // format, comment);
   } else if (type == "integer") {
     convert_to_binsparse<int64_t, I>(input_file, output_file, format, comment);
   } else if (type == "pattern") {
     convert_to_binsparse<uint8_t, 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";
+    std::cout << "usage: ./convert_binsparse [input_file.mtx] "
+                 "[output_file.hdf5] [optional: format {CSR, COO}]\n";
     return 1;
   }
 
@@ -61,7 +72,8 @@ int main(int argc, char** argv) {
 
   auto [m, n, nnz, type, comment] = binsparse::mmread_metadata(input_file);
 
-  std::cout << "Matrix is " << m << " x " << n << " with " << nnz << " values.\n";
+  std::cout << "Matrix is " << m << " x " << n << " with " << nnz
+            << " values.\n";
   std::cout << "Type: " << type << std::endl;
   std::cout << "Comment:\n";
   std::cout << comment;
@@ -71,15 +83,20 @@ int main(int argc, char** argv) {
   auto max_size = std::max({m, n, nnz});
 
   if (max_size + 1 <= std::numeric_limits<uint8_t>::max()) {
-    convert_to_binsparse<uint8_t>(input_file, output_file, type, format, comment);
+    convert_to_binsparse<uint8_t>(input_file, output_file, type, format,
+                                  comment);
   } else if (max_size + 1 <= std::numeric_limits<uint16_t>::max()) {
-    convert_to_binsparse<uint16_t>(input_file, output_file, type, format, comment);
+    convert_to_binsparse<uint16_t>(input_file, output_file, type, format,
+                                   comment);
   } else if (max_size + 1 <= std::numeric_limits<uint32_t>::max()) {
-    convert_to_binsparse<uint32_t>(input_file, output_file, type, format, comment);
+    convert_to_binsparse<uint32_t>(input_file, output_file, type, format,
+                                   comment);
   } else if (max_size + 1 <= std::numeric_limits<uint64_t>::max()) {
-    convert_to_binsparse<uint64_t>(input_file, output_file, type, format, comment);
+    convert_to_binsparse<uint64_t>(input_file, output_file, type, format,
+                                   comment);
   } else {
-    throw std::runtime_error("Error! Matrix dimensions or NNZ too large to handle.");
+    throw std::runtime_error(
+        "Error! Matrix dimensions or NNZ too large to handle.");
   }
 
   return 0;

examples/convert_matrixmarket.cpp

@@ -1,7 +1,7 @@
 #include <binsparse/binsparse.hpp>
-#include <iostream>
-#include <concepts>
 #include <complex>
+#include <concepts>
+#include <iostream>
 
 int main(int argc, char** argv) {
 
@@ -16,38 +16,43 @@ int main(int argc, char** argv) {
 
   std::cout << "Inspecting Binsparse v" << metadata["version"] << " file...\n";
   std::cout << metadata["format"] << " format matrix of dimension "
-            << metadata["shape"] << " with " << metadata["nnz"] << " nonzeros\n";
+            << metadata["shape"] << " with " << metadata["nnz"]
+            << " nonzeros\n";
 
   if (metadata["format"] == "COO") {
     auto i0 = metadata["data_types"]["indices_0"];
     auto i1 = metadata["data_types"]["indices_1"];
     auto t = metadata["data_types"]["values"];
 
-    binsparse::visit_label({i0, i1, t},
-                [&]<typename I1, typename I2, typename T>(I1 i, I2 j, T v) {
-                  using I = std::conditional_t<std::numeric_limits<I1>::max() < std::numeric_limits<I2>::max(),
-                                               I2, I1>;
-                  std::cout << "Reading binsparse with index and value types: "
-                            << binsparse::type_info<I>::label() << " "
-                            << binsparse::type_info<T>::label() << "\n";
-
-                  auto m = binsparse::read_coo_matrix<T, I>(input_file);
-                });
+    binsparse::visit_label(
+        {i0, i1, t},
+        [&]<typename I1, typename I2, typename T>(I1 i, I2 j, T v) {
+          using I = std::conditional_t<std::numeric_limits<I1>::max() <
+                                           std::numeric_limits<I2>::max(),
+                                       I2, I1>;
+          std::cout << "Reading binsparse with index and value types: "
+                    << binsparse::type_info<I>::label() << " "
+                    << binsparse::type_info<T>::label() << "\n";
+
+          auto m = binsparse::read_coo_matrix<T, I>(input_file);
+        });
   } else if (metadata["format"] == "CSR") {
     auto i0 = metadata["data_types"]["pointers_to_1"];
     auto i1 = metadata["data_types"]["indices_1"];
     auto t = metadata["data_types"]["values"];
 
-    binsparse::visit_label({i0, i1, t},
-                [&]<typename I1, typename I2, typename T>(I1 i, I2 j, T v) {
-                  using I = std::conditional_t<std::numeric_limits<I1>::max() < std::numeric_limits<I2>::max(),
-                                               I2, I1>;
-                  std::cout << "Reading binsparse with index and value types: "
-                            << binsparse::type_info<I>::label() << " "
-                            << binsparse::type_info<T>::label() << "\n";
-
-                  auto m = binsparse::read_csr_matrix<T, I>(input_file);
-                });
+    binsparse::visit_label(
+        {i0, i1, t},
+        [&]<typename I1, typename I2, typename T>(I1 i, I2 j, T v) {
+          using I = std::conditional_t<std::numeric_limits<I1>::max() <
+                                           std::numeric_limits<I2>::max(),
+                                       I2, I1>;
+          std::cout << "Reading binsparse with index and value types: "
+                    << binsparse::type_info<I>::label() << " "
+                    << binsparse::type_info<T>::label() << "\n";
+
+          auto m = binsparse::read_csr_matrix<T, I>(input_file);
+        });
   } else {
     assert(false);
   }

examples/inspect_binsparse.cpp

@@ -1,7 +1,7 @@
 #include <binsparse/binsparse.hpp>
-#include <iostream>
-#include <concepts>
 #include <complex>
+#include <concepts>
+#include <iostream>
 #include <ranges>
 
 class Foo {};
@@ -21,7 +21,8 @@ int main(int argc, char** argv) {
 
   std::cout << "Inspecting Binsparse v" << metadata["version"] << " file...\n";
   std::cout << metadata["format"] << " format matrix of dimension "
-            << metadata["shape"] << " with " << metadata["nnz"] << " nonzeros\n";
+            << metadata["shape"] << " with " << metadata["nnz"]
+            << " nonzeros\n";
 
   if (metadata["format"] == "COO") {
     auto i0 = metadata["data_types"]["indices_0"];
@@ -40,7 +41,6 @@ int main(int argc, char** argv) {
     assert(false);
   }
 
-  
   nlohmann::json user;
   std::cout << "User-provided keys:\n";
   std::size_t n_keys = 0;

examples/simple_io.cpp

@@ -1,11 +1,12 @@
-#include <iostream>
 #include <binsparse/binsparse.hpp>
+#include <iostream>
 
 int main(int argc, char** argv) {
   auto mat = binsparse::read_coo_matrix<float, std::size_t>("data/matrix.hdf5");
 
   for (size_t i = 0; i < mat.nnz; i++) {
-    std::cout << mat.rowind[i] << ", " << mat.colind[i] << ": " << mat.values[i] << std::endl;
+    std::cout << mat.rowind[i] << ", " << mat.colind[i] << ": " << mat.values[i]
+              << std::endl;
   }
 
   binsparse::write_coo_matrix("new_matrix.hdf5", mat);