Add error handling to bsp_matrix_t functions.

BenBrock · BenBrock · commit d1801b96a21d · 2025-08-18T20:51:10.000Z
diff --git a/examples/benchmark_read.c b/examples/benchmark_read.c
@@ -80,7 +80,7 @@ int main(int argc, char** argv) {
   // If running warm cache experiments, read once to warm cache.
   if (!cold_cache) {
     bsp_matrix_t mat = bsp_read_matrix(file_name, NULL);
-    bsp_destroy_matrix_t(mat);
+    bsp_destroy_matrix_t(&mat);
   }
 
   for (size_t i = 0; i < num_trials; i++) {
@@ -92,7 +92,7 @@ int main(int argc, char** argv) {
     double end = gettime();
     durations[i] = end - begin;
     nbytes = bsp_matrix_nbytes(mat);
-    bsp_destroy_matrix_t(mat);
+    bsp_destroy_matrix_t(&mat);
 
     double gbytes = ((double) nbytes) / 1024 / 1024 / 1024;
     double gbytes_s = gbytes / durations[i];
diff --git a/examples/benchmark_read_parallel.c b/examples/benchmark_read_parallel.c
@@ -83,7 +83,7 @@ int main(int argc, char** argv) {
   // If running warm cache experiments, read once to warm cache.
   if (!cold_cache) {
     bsp_matrix_t mat = bsp_read_matrix_parallel(file_name, NULL, num_threads);
-    bsp_destroy_matrix_t(mat);
+    bsp_destroy_matrix_t(&mat);
   }
 
   for (size_t i = 0; i < num_trials; i++) {
@@ -97,7 +97,7 @@ int main(int argc, char** argv) {
     durations[i] = end - begin;
     nbytes = bsp_matrix_nbytes(mat);
 
-    bsp_destroy_matrix_t(mat);
+    bsp_destroy_matrix_t(&mat);
 
     double gbytes = ((double) nbytes) / 1024 / 1024 / 1024;
     double gbytes_s = gbytes / durations[i];
diff --git a/examples/bsp2mtx.c b/examples/bsp2mtx.c
@@ -29,7 +29,7 @@ int main(int argc, char** argv) {
   bsp_mmwrite(output_fname, matrix);
   printf(" === Done writing. ===\n");
 
-  bsp_destroy_matrix_t(matrix);
+  bsp_destroy_matrix_t(&matrix);
 
   return 0;
 }
diff --git a/examples/check_equivalence.c b/examples/check_equivalence.c
@@ -128,13 +128,13 @@ int main(int argc, char** argv) {
   if (matrix1.format != matrix2.format) {
     if (matrix1.format != BSP_COOR) {
       bsp_matrix_t intermediate = bsp_convert_matrix(matrix1, BSP_COOR);
-      bsp_destroy_matrix_t(matrix1);
+      bsp_destroy_matrix_t(&matrix1);
       matrix1 = intermediate;
     }
 
     if (matrix2.format != BSP_COOR) {
       bsp_matrix_t intermediate = bsp_convert_matrix(matrix2, BSP_COOR);
-      bsp_destroy_matrix_t(matrix2);
+      bsp_destroy_matrix_t(&matrix2);
       matrix2 = intermediate;
     }
   }
diff --git a/examples/check_equivalence_parallel.c b/examples/check_equivalence_parallel.c
@@ -136,13 +136,13 @@ int main(int argc, char** argv) {
   if (matrix1.format != matrix2.format) {
     if (matrix1.format != BSP_COOR) {
       bsp_matrix_t intermediate = bsp_convert_matrix(matrix1, BSP_COOR);
-      bsp_destroy_matrix_t(matrix1);
+      bsp_destroy_matrix_t(&matrix1);
       matrix1 = intermediate;
     }
 
     if (matrix2.format != BSP_COOR) {
       bsp_matrix_t intermediate = bsp_convert_matrix(matrix2, BSP_COOR);
-      bsp_destroy_matrix_t(matrix2);
+      bsp_destroy_matrix_t(&matrix2);
       matrix2 = intermediate;
     }
   }
diff --git a/examples/mtx2bsp.c b/examples/mtx2bsp.c
@@ -151,7 +151,7 @@ int main(int argc, char** argv) {
   if (format != BSP_COOR) {
     begin = gettime();
     bsp_matrix_t converted_matrix = bsp_convert_matrix(matrix, format);
-    bsp_destroy_matrix_t(matrix);
+    bsp_destroy_matrix_t(&matrix);
     matrix = converted_matrix;
     end = gettime();
     duration = end - begin;
@@ -170,7 +170,7 @@ int main(int argc, char** argv) {
   printf("%lf seconds writing Binsparse file...\n", duration);
   printf(" === Done writing. ===\n");
 
-  bsp_destroy_matrix_t(matrix);
+  bsp_destroy_matrix_t(&matrix);
 
   return 0;
 }
diff --git a/include/binsparse/array.h b/include/binsparse/array.h
@@ -20,12 +20,11 @@ typedef struct bsp_array_t {
   bsp_allocator_t allocator;
 } bsp_array_t;
 
-static inline bsp_array_t bsp_construct_default_array_t() {
-  bsp_array_t array;
-  array.data = NULL;
-  array.size = 0;
-  array.allocator = bsp_default_allocator;
-  return array;
+static inline bsp_error_t bsp_construct_default_array_t(bsp_array_t* array) {
+  array->data = NULL;
+  array->size = 0;
+  array->allocator = bsp_default_allocator;
+  return BSP_SUCCESS;
 }
 
 static inline bsp_error_t bsp_construct_array_t(bsp_array_t* array, size_t size,
diff --git a/include/binsparse/convert_matrix.h b/include/binsparse/convert_matrix.h
@@ -20,7 +20,8 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
     // *Convert to COO* from another format.
     if (matrix.format == BSP_CSR) {
       // Convert CSR -> COOR
-      bsp_matrix_t result = bsp_construct_default_matrix_t();
+      bsp_matrix_t result;
+      bsp_construct_default_matrix_t(&result);
 
       result.format = BSP_COOR;
 
@@ -40,7 +41,9 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
       bsp_error_t error =
           bsp_copy_construct_array_t(&result.values, matrix.values);
       if (error != BSP_SUCCESS) {
-        return bsp_construct_default_matrix_t();
+        bsp_matrix_t empty_result;
+        bsp_construct_default_matrix_t(&empty_result);
+        return empty_result;
       }
 
       // There is a corner case with tall and skinny matrices where we need a
@@ -51,14 +54,18 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
         error = bsp_copy_construct_array_t(&result.indices_1, matrix.indices_1);
         if (error != BSP_SUCCESS) {
           bsp_destroy_array_t(&result.values);
-          return bsp_construct_default_matrix_t();
+          bsp_matrix_t empty_result;
+          bsp_construct_default_matrix_t(&empty_result);
+          return empty_result;
         }
       } else {
         error = bsp_construct_array_t(&result.indices_1, matrix.indices_1.size,
                                       index_type);
         if (error != BSP_SUCCESS) {
           bsp_destroy_array_t(&result.values);
-          return bsp_construct_default_matrix_t();
+          bsp_matrix_t empty_result;
+          bsp_construct_default_matrix_t(&empty_result);
+          return empty_result;
         }
 
         for (size_t i = 0; i < matrix.indices_1.size; i++) {
@@ -72,7 +79,9 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
       if (error != BSP_SUCCESS) {
         bsp_destroy_array_t(&result.values);
         bsp_destroy_array_t(&result.indices_1);
-        return bsp_construct_default_matrix_t();
+        bsp_matrix_t empty_result;
+        bsp_construct_default_matrix_t(&empty_result);
+        return empty_result;
       }
 
       for (size_t i = 0; i < matrix.nrows; i++) {
@@ -95,13 +104,14 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
     if (matrix.format != BSP_COOR) {
       bsp_matrix_t intermediate = bsp_convert_matrix(matrix, BSP_COOR);
       bsp_matrix_t result = bsp_convert_matrix(intermediate, format);
-      bsp_destroy_matrix_t(intermediate);
+      bsp_destroy_matrix_t(&intermediate);
       return result;
     } else {
       if (format == BSP_CSR) {
         // Convert COOR -> CSR
 
-        bsp_matrix_t result = bsp_construct_default_matrix_t();
+        bsp_matrix_t result;
+        bsp_construct_default_matrix_t(&result);
 
         result.format = BSP_CSR;
 
@@ -130,22 +140,28 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
         bsp_error_t error =
             bsp_copy_construct_array_t(&result.values, matrix.values);
         if (error != BSP_SUCCESS) {
-          return bsp_construct_default_matrix_t();
+          bsp_matrix_t empty_result;
+          bsp_construct_default_matrix_t(&empty_result);
+          return empty_result;
         }
 
         if (index_type == matrix.indices_1.type) {
           error =
               bsp_copy_construct_array_t(&result.indices_1, matrix.indices_1);
           if (error != BSP_SUCCESS) {
             bsp_destroy_array_t(&result.values);
-            return bsp_construct_default_matrix_t();
+            bsp_matrix_t empty_result;
+            bsp_construct_default_matrix_t(&empty_result);
+            return empty_result;
           }
         } else {
           error =
               bsp_construct_array_t(&result.indices_1, matrix.nnz, index_type);
           if (error != BSP_SUCCESS) {
             bsp_destroy_array_t(&result.values);
-            return bsp_construct_default_matrix_t();
+            bsp_matrix_t empty_result;
+            bsp_construct_default_matrix_t(&empty_result);
+            return empty_result;
           }
 
           for (size_t i = 0; i < matrix.nnz; i++) {
@@ -160,7 +176,9 @@ static inline bsp_matrix_t bsp_convert_matrix(bsp_matrix_t matrix,
         if (error != BSP_SUCCESS) {
           bsp_destroy_array_t(&result.values);
           bsp_destroy_array_t(&result.indices_1);
-          return bsp_construct_default_matrix_t();
+          bsp_matrix_t empty_result;
+          bsp_construct_default_matrix_t(&empty_result);
+          return empty_result;
         }
 
         bsp_array_t rowptr = result.pointers_to_1;
diff --git a/include/binsparse/generate.h b/include/binsparse/generate.h
@@ -70,13 +70,13 @@ static inline void bsp_array_fill_random(bsp_array_t array, size_t bound) {
 static inline bsp_matrix_t bsp_generate_coo(size_t m, size_t n, size_t nnz,
                                             bsp_type_t value_type,
                                             bsp_type_t index_type) {
-  bsp_matrix_t matrix = bsp_construct_default_matrix_t();
+  bsp_matrix_t matrix;
+  bsp_construct_default_matrix_t(&matrix);
   matrix.nrows = m;
   matrix.ncols = n;
   matrix.nnz = nnz;
 
-  bsp_error_t error;
-  error = bsp_construct_array_t(&matrix.values, nnz, value_type);
+  bsp_error_t error = bsp_construct_array_t(&matrix.values, nnz, value_type);
   if (error != BSP_SUCCESS) {
     // Return empty matrix on error
     return matrix;
diff --git a/include/binsparse/hdf5_wrapper.h b/include/binsparse/hdf5_wrapper.h
@@ -84,21 +84,27 @@ static inline bsp_array_t bsp_read_array_parallel(hid_t f, const char* label,
   hid_t dset = H5Dopen2(f, label, H5P_DEFAULT);
 
   if (dset == H5I_INVALID_HID) {
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   hid_t fspace = H5Dget_space(dset);
 
   if (fspace == H5I_INVALID_HID) {
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   hsize_t dims[3];
 
   int r = H5Sget_simple_extent_dims(fspace, dims, NULL);
 
   if (r < 0) {
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   hid_t hdf5_type = H5Dget_type(dset);
@@ -180,33 +186,44 @@ static inline bsp_array_t bsp_read_array(hid_t f, const char* label) {
   hid_t dset = H5Dopen2(f, label, H5P_DEFAULT);
 
   if (dset == H5I_INVALID_HID) {
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   hid_t fspace = H5Dget_space(dset);
 
   if (fspace == H5I_INVALID_HID) {
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   hsize_t dims[3];
 
   int r = H5Sget_simple_extent_dims(fspace, dims, NULL);
 
   if (r < 0) {
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   hid_t hdf5_type = H5Dget_type(dset);
 
   bsp_type_t type = bsp_get_bsp_type(hdf5_type);
 
-  bsp_array_t array = bsp_construct_default_array_t();
+  bsp_array_t array;
+  bsp_construct_default_array_t(&array);
+
   bsp_error_t error = bsp_construct_array_t(&array, dims[0], type);
   if (error != BSP_SUCCESS) {
+    bsp_destroy_array_t(&array);
     H5Dclose(dset);
     H5Sclose(fspace);
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   herr_t status = H5Dread(dset, bsp_get_hdf5_native_type(type), H5S_ALL,
@@ -216,7 +233,9 @@ static inline bsp_array_t bsp_read_array(hid_t f, const char* label) {
     bsp_destroy_array_t(&array);
     H5Dclose(dset);
     H5Sclose(fspace);
-    return bsp_construct_default_array_t();
+    bsp_array_t empty_array;
+    bsp_construct_default_array_t(&empty_array);
+    return empty_array;
   }
 
   H5Dclose(dset);
diff --git a/include/binsparse/matrix.h b/include/binsparse/matrix.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include <binsparse/array.h>
+#include <binsparse/error.h>
 #include <binsparse/matrix_formats.h>
 #include <binsparse/structure.h>
 #include <stdbool.h>
@@ -26,23 +27,21 @@ typedef struct bsp_matrix_t {
   bsp_structure_t structure;
 } bsp_matrix_t;
 
-static inline bsp_matrix_t bsp_construct_default_matrix_t() {
-  bsp_matrix_t mat;
-  mat.values = bsp_construct_default_array_t();
-  mat.indices_0 = bsp_construct_default_array_t();
-  mat.indices_1 = bsp_construct_default_array_t();
-  mat.pointers_to_1 = bsp_construct_default_array_t();
-  mat.nrows = mat.ncols = mat.nnz = 0;
-  mat.is_iso = false;
-  mat.structure = BSP_GENERAL;
-  return mat;
+static inline void bsp_construct_default_matrix_t(bsp_matrix_t* matrix) {
+  bsp_construct_default_array_t(&matrix->values);
+  bsp_construct_default_array_t(&matrix->indices_0);
+  bsp_construct_default_array_t(&matrix->indices_1);
+  bsp_construct_default_array_t(&matrix->pointers_to_1);
+  matrix->nrows = matrix->ncols = matrix->nnz = 0;
+  matrix->is_iso = false;
+  matrix->structure = BSP_GENERAL;
 }
 
-static inline void bsp_destroy_matrix_t(bsp_matrix_t matrix) {
-  bsp_destroy_array_t(&matrix.values);
-  bsp_destroy_array_t(&matrix.indices_0);
-  bsp_destroy_array_t(&matrix.indices_1);
-  bsp_destroy_array_t(&matrix.pointers_to_1);
+static inline void bsp_destroy_matrix_t(bsp_matrix_t* matrix) {
+  bsp_destroy_array_t(&matrix->values);
+  bsp_destroy_array_t(&matrix->indices_0);
+  bsp_destroy_array_t(&matrix->indices_1);
+  bsp_destroy_array_t(&matrix->pointers_to_1);
 }
 
 static inline size_t bsp_matrix_nbytes(bsp_matrix_t mat) {
diff --git a/include/binsparse/matrix_market/matrix_market_read.h b/include/binsparse/matrix_market/matrix_market_read.h
@@ -32,7 +32,8 @@ static inline bsp_matrix_t bsp_mmread_explicit_array(const char* file_path,
     assert(false);
   }
 
-  bsp_matrix_t matrix = bsp_construct_default_matrix_t();
+  bsp_matrix_t matrix;
+  bsp_construct_default_matrix_t(&matrix);
 
   matrix.nrows = metadata.nrows;
   matrix.ncols = metadata.ncols;
@@ -129,7 +130,8 @@ bsp_mmread_explicit_coordinate(const char* file_path, bsp_type_t value_type,
     assert(false);
   }
 
-  bsp_matrix_t matrix = bsp_construct_default_matrix_t();
+  bsp_matrix_t matrix;
+  bsp_construct_default_matrix_t(&matrix);
 
   if (mm_type == BSP_MM_PATTERN) {
     matrix.is_iso = true;
diff --git a/src/read_matrix.c b/src/read_matrix.c

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ int main(int argc, char** argv) {`
`29`	`29`	`bsp_mmwrite(output_fname, matrix);`
`30`	`30`	`printf(" === Done writing. ===\n");`
`31`	`31`
`32`		`- bsp_destroy_matrix_t(matrix);`
	`32`	`+ bsp_destroy_matrix_t(&matrix);`
`33`	`33`
`34`	`34`	`return 0;`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,13 +128,13 @@ int main(int argc, char** argv) {`
`128`	`128`	`if (matrix1.format != matrix2.format) {`
`129`	`129`	`if (matrix1.format != BSP_COOR) {`
`130`	`130`	`bsp_matrix_t intermediate = bsp_convert_matrix(matrix1, BSP_COOR);`
`131`		`- bsp_destroy_matrix_t(matrix1);`
	`131`	`+ bsp_destroy_matrix_t(&matrix1);`
`132`	`132`	`matrix1 = intermediate;`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`if (matrix2.format != BSP_COOR) {`
`136`	`136`	`bsp_matrix_t intermediate = bsp_convert_matrix(matrix2, BSP_COOR);`
`137`		`- bsp_destroy_matrix_t(matrix2);`
	`137`	`+ bsp_destroy_matrix_t(&matrix2);`
`138`	`138`	`matrix2 = intermediate;`
`139`	`139`	`}`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -136,13 +136,13 @@ int main(int argc, char** argv) {`
`136`	`136`	`if (matrix1.format != matrix2.format) {`
`137`	`137`	`if (matrix1.format != BSP_COOR) {`
`138`	`138`	`bsp_matrix_t intermediate = bsp_convert_matrix(matrix1, BSP_COOR);`
`139`		`- bsp_destroy_matrix_t(matrix1);`
	`139`	`+ bsp_destroy_matrix_t(&matrix1);`
`140`	`140`	`matrix1 = intermediate;`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`if (matrix2.format != BSP_COOR) {`
`144`	`144`	`bsp_matrix_t intermediate = bsp_convert_matrix(matrix2, BSP_COOR);`
`145`		`- bsp_destroy_matrix_t(matrix2);`
	`145`	`+ bsp_destroy_matrix_t(&matrix2);`
`146`	`146`	`matrix2 = intermediate;`
`147`	`147`	`}`
`148`	`148`	`}`