Some debugging/cleanup

Author: BenBrock

bindings/matlab/binsparse_from_ssmc.c

@@ -333,7 +333,8 @@ void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
 
   bsp_matrix_t result = csc_matrix;
   if (target_format != BSP_CSC) {
-    result = bsp_convert_matrix(csc_matrix, target_format);
+    result = bsp_convert_matrix_allocator(csc_matrix, target_format,
+                                          bsp_matlab_allocator);
     bsp_destroy_matrix_t(&csc_matrix);
 
     if (result.format != target_format) {

bindings/matlab/binsparse_minimize_types.c

@@ -49,7 +49,6 @@ static void minimize_iso_values(bsp_matrix_t* matrix) {
       uint64_t current = 0;
       bsp_array_read((*values), i, current);
       if (current != first) {
-        mexPrintf("%lu != %lu\n", current, first);
         all_equal = false;
         break;
       }
@@ -93,7 +92,6 @@ static void minimize_iso_values(bsp_matrix_t* matrix) {
       int64_t current = 0;
       bsp_array_read((*values), i, current);
       if (current != first) {
-        mexPrintf("%lu != %lu\n", current, first);
         all_equal = false;
         break;
       }
@@ -133,7 +131,6 @@ static void minimize_iso_values(bsp_matrix_t* matrix) {
       float current = 0.0f;
       bsp_array_read((*values), i, current);
       if (current != first) {
-        mexPrintf("%lu != %lu\n", current, first);
         all_equal = false;
         break;
       }
@@ -162,7 +159,6 @@ static void minimize_iso_values(bsp_matrix_t* matrix) {
       double current = 0.0;
       bsp_array_read((*values), i, current);
       if (current != first) {
-        mexPrintf("%lu != %lu\n", current, first);
         all_equal = false;
         break;
       }
@@ -227,8 +223,6 @@ static void minimize_iso_values(bsp_matrix_t* matrix) {
       return;
     }
 
-    mexPrintf("All equal!\n");
-
     bsp_array_t new_values;
     bsp_error_t error = bsp_construct_array_t_allocator(
         &new_values, 1, values->type, bsp_matlab_allocator);
@@ -495,7 +489,6 @@ static void minimize_index_array(bsp_array_t* array, const char* name) {
 }
 
 void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
-  mexPrintf("Running binsparse_minimize_types\n");
   if (nrhs != 1) {
     mexErrMsgIdAndTxt("BinSparse:InvalidArgs",
                       "Usage: matrix = binsparse_minimize_types(matrix)");
@@ -523,7 +516,6 @@ void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
   minimize_index_array(&matrix.indices_0, "indices_0");
   minimize_index_array(&matrix.indices_1, "indices_1");
   minimize_index_array(&matrix.pointers_to_1, "pointers_to_1");
-  mexPrintf("Minimizing ISO values:\n");
   minimize_iso_values(&matrix);
 
   plhs[0] = bsp_matrix_to_matlab_struct(&matrix);

bindings/matlab/binsparse_read.c

@@ -19,14 +19,8 @@
 #include <binsparse/binsparse.h>
 #include <string.h>
 
-static inline void* bsp_matlab_malloc(size_t size) {
-  void* ptr = mxMalloc(size);
-  mexMakeMemoryPersistent(ptr);
-  return ptr;
-}
-
-static const bsp_allocator_t bsp_matlab_allocator = {
-    .malloc = bsp_matlab_malloc, .free = mxFree};
+static const bsp_allocator_t bsp_matlab_allocator = {.malloc = mxMalloc,
+                                                     .free = mxFree};
 
 static inline mxClassID get_mxClassID(bsp_type_t type) {
   switch (type) {
@@ -71,15 +65,19 @@ static inline mxComplexity get_mxComplexity(bsp_type_t type) {
 
 mxArray* bsp_array_to_matlab(bsp_array_t* array) {
   if (array->data == NULL || array->size == 0) {
-    // Return empty array
-    return mxCreateDoubleMatrix(1, 1, mxREAL);
+    // Return empty array of the correct class
+    mxClassID class_id = get_mxClassID(array->type);
+    if (class_id == mxUNKNOWN_CLASS) {
+      class_id = mxDOUBLE_CLASS;
+    }
+    return mxCreateNumericMatrix(0, 1, class_id, get_mxComplexity(array->type));
   }
 
   if (get_mxClassID(array->type) == mxUNKNOWN_CLASS) {
     mexWarnMsgIdAndTxt("BinSparse:UnsupportedType",
                        "Unsupported array type %d, returning empty array",
                        (int) array->type);
-    return mxCreateDoubleMatrix(1, 1, mxREAL);
+    return mxCreateNumericMatrix(0, 1, mxDOUBLE_CLASS, mxREAL);
   }
 
   mxArray* mx_array = NULL;

bindings/matlab/matlab_bsp_helpers.h

@@ -64,9 +64,7 @@ static inline int extract_matlab_csc(const mxArray* mx_matrix,
 static inline bsp_error_t
 matlab_to_bsp_array_allocator(const mxArray* mx_array, bsp_array_t* array,
                               bsp_allocator_t allocator) {
-  if (mxIsEmpty(mx_array)) {
-    return bsp_construct_default_array_t_allocator(array, allocator);
-  }
+  bool is_empty = mxIsEmpty(mx_array);
 
   size_t size = mxGetNumberOfElements(mx_array);
   mxClassID class_id = mxGetClassID(mx_array);
@@ -132,6 +130,14 @@ matlab_to_bsp_array_allocator(const mxArray* mx_array, bsp_array_t* array,
     }
   }
 
+  if (is_empty) {
+    array->data = NULL;
+    array->size = 0;
+    array->type = bsp_type;
+    array->allocator = allocator;
+    return BSP_SUCCESS;
+  }
+
   bsp_error_t error =
       bsp_construct_array_t_allocator(array, size, bsp_type, allocator);
   if (error != BSP_SUCCESS) {
@@ -372,14 +378,24 @@ static inline mxComplexity get_mxComplexity(bsp_type_t type) {
 
 static inline mxArray* bsp_array_to_matlab(bsp_array_t* array) {
   if (!array || array->data == NULL || array->size == 0) {
-    return mxCreateDoubleMatrix(0, 0, mxREAL);
+    bsp_type_t type = array ? array->type : BSP_FLOAT64;
+    mxClassID class_id = get_mxClassID(type);
+    if (class_id == mxUNKNOWN_CLASS) {
+      class_id = mxDOUBLE_CLASS;
+      type = BSP_FLOAT64;
+    }
+    mxArray* empty_array =
+        mxCreateNumericMatrix(0, 1, class_id, get_mxComplexity(type));
+    return empty_array;
   }
 
   if (get_mxClassID(array->type) == mxUNKNOWN_CLASS) {
     mexWarnMsgIdAndTxt("BinSparse:UnsupportedType",
                        "Unsupported array type %d, returning empty array",
                        (int) array->type);
-    return mxCreateDoubleMatrix(0, 0, mxREAL);
+    mxArray* empty_array = mxCreateNumericMatrix(
+        0, 1, get_mxClassID(array->type), get_mxComplexity(array->type));
+    return empty_array;
   }
 
   mxArray* mx_array = NULL;

include/binsparse/array.h

@@ -25,6 +25,7 @@ bsp_construct_default_array_t_allocator(bsp_array_t* array,
                                         bsp_allocator_t allocator) {
   array->data = NULL;
   array->size = 0;
+  array->type = BSP_INVALID_TYPE;
   array->allocator = allocator;
   return BSP_SUCCESS;
 }