diff --git a/CMakeLists.txt b/CMakeLists.txt index a215b43..9ea1903 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.20) +cmake_minimum_required(VERSION 3.5) project(binsparse-rc) set(CMAKE_C_STANDARD 11) diff --git a/include/binsparse/array.h b/include/binsparse/array.h index a177ad7..1371b88 100644 --- a/include/binsparse/array.h +++ b/include/binsparse/array.h @@ -73,46 +73,48 @@ void bsp_destroy_array_t(bsp_array_t array) { free(array.data); } +#ifndef __cplusplus + #define bsp_array_block(array, ptr, code_block) \ { \ if (array.type == BSP_UINT8) { \ - uint8_t* ptr = array.data; \ + uint8_t* ptr = (uint8_t*) array.data; \ code_block; \ } else if (array.type == BSP_UINT16) { \ - uint16_t* ptr = array.data; \ + uint16_t* ptr = (uint16_t*) array.data; \ code_block; \ } else if (array.type == BSP_UINT32) { \ - uint32_t* ptr = array.data; \ + uint32_t* ptr = (uint32_t*) array.data; \ code_block; \ } else if (array.type == BSP_UINT64) { \ - uint64_t* ptr = array.data; \ + uint64_t* ptr = (uint64_t*) array.data; \ code_block; \ } else if (array.type == BSP_INT8) { \ - int8_t* ptr = array.data; \ + int8_t* ptr = (int8_t*) array.data; \ code_block; \ } else if (array.type == BSP_INT16) { \ - int16_t* ptr = array.data; \ + int16_t* ptr = (int16_t*) array.data; \ code_block; \ } else if (array.type == BSP_INT32) { \ - int32_t* ptr = array.data; \ + int32_t* ptr = (int32_t*) array.data; \ code_block; \ } else if (array.type == BSP_INT64) { \ - int64_t* ptr = array.data; \ + int64_t* ptr = (int64_t*) array.data; \ code_block; \ } else if (array.type == BSP_FLOAT32) { \ - float* ptr = array.data; \ + float* ptr = (float*) array.data; \ code_block; \ } else if (array.type == BSP_FLOAT64) { \ - double* ptr = array.data; \ + double* ptr = (float*) array.data; \ code_block; \ } else if (array.type == BSP_BINT8) { \ - int8_t* ptr = array.data; \ + int8_t* ptr = (int8_t*) array.data; \ code_block; \ } else if (array.type == BSP_COMPLEX_FLOAT32) { \ - float _Complex* ptr = array.data; \ + float _Complex* ptr = (float _Complex*) array.data; \ code_block; \ } else if (array.type == BSP_COMPLEX_FLOAT64) { \ - double _Complex* ptr = array.data; \ + double _Complex* ptr = (double _Complex*) array.data; \ code_block; \ } \ } @@ -121,43 +123,43 @@ void bsp_destroy_array_t(bsp_array_t array) { #define bsp_array_write(array, index, value) \ { \ if (array.type == BSP_UINT8) { \ - uint8_t* data = array.data; \ + uint8_t* data = (uint8_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_UINT16) { \ - uint16_t* data = array.data; \ + uint16_t* data = (uint16_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_UINT32) { \ - uint32_t* data = array.data; \ + uint32_t* data = (uint32_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_UINT64) { \ - uint64_t* data = array.data; \ + uint64_t* data = (uint64_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_INT8) { \ - int8_t* data = array.data; \ + int8_t* data = (int8_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_INT16) { \ - int16_t* data = array.data; \ + int16_t* data = (int16_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_INT32) { \ - int32_t* data = array.data; \ + int32_t* data = (int32_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_INT64) { \ - int64_t* data = array.data; \ + int64_t* data = (int64_t*) array.data; \ data[index] = value; \ } else if (array.type == BSP_FLOAT32) { \ - float* data = array.data; \ + float* data = (float*) array.data; \ data[index] = value; \ } else if (array.type == BSP_FLOAT64) { \ - double* data = array.data; \ + double* data = (double*) array.data; \ data[index] = value; \ } else if (array.type == BSP_BINT8) { \ - int8_t* data = array.data; \ + int8_t* data = (int8_t*) array.data; \ data[index] = ((size_t) value) % 2; \ } else if (array.type == BSP_COMPLEX_FLOAT32) { \ - float _Complex* data = array.data; \ + float _Complex* data = (float _Complex*) array.data; \ data[index] = value; \ } else if (array.type == BSP_COMPLEX_FLOAT64) { \ - double _Complex* data = array.data; \ + double _Complex* data = (double _Complex*) array.data; \ data[index] = value; \ } \ } @@ -166,56 +168,56 @@ void bsp_destroy_array_t(bsp_array_t array) { #define bsp_array_awrite(array_0, index_0, array_1, index_1) \ { \ if (array_0.type == BSP_UINT8) { \ - uint8_t* data0 = array_0.data; \ - uint8_t* data1 = array_1.data; \ + uint8_t* data0 = (uint8_t*) array_0.data; \ + uint8_t* data1 = (uint8_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_UINT16) { \ - uint16_t* data0 = array_0.data; \ - uint16_t* data1 = array_1.data; \ + uint16_t* data0 = (uint16_t*) array_0.data; \ + uint16_t* data1 = (uint16_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_UINT32) { \ - uint32_t* data0 = array_0.data; \ - uint32_t* data1 = array_1.data; \ + uint32_t* data0 = (uint32_t*) array_0.data; \ + uint32_t* data1 = (uint32_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_UINT64) { \ - uint64_t* data0 = array_0.data; \ - uint64_t* data1 = array_1.data; \ + uint64_t* data0 = (uint64_t*) array_0.data; \ + uint64_t* data1 = (uint64_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_INT8) { \ - int8_t* data0 = array_0.data; \ - int8_t* data1 = array_1.data; \ + int8_t* data0 = (int8_t*) array_0.data; \ + int8_t* data1 = (int8_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_INT16) { \ - int16_t* data0 = array_0.data; \ - int16_t* data1 = array_1.data; \ + int16_t* data0 = (int16_t*) array_0.data; \ + int16_t* data1 = (int16_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_INT32) { \ - int32_t* data0 = array_0.data; \ - int32_t* data1 = array_1.data; \ + int32_t* data0 = (int32_t*) array_0.data; \ + int32_t* data1 = (int32_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_INT64) { \ - int64_t* data0 = array_0.data; \ - int64_t* data1 = array_1.data; \ + int64_t* data0 = (int64_t*) array_0.data; \ + int64_t* data1 = (int64_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_FLOAT32) { \ - float* data0 = array_0.data; \ - float* data1 = array_1.data; \ + float* data0 = (float*) array_0.data; \ + float* data1 = (float*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_FLOAT64) { \ - double* data0 = array_0.data; \ - double* data1 = array_1.data; \ + double* data0 = (double*) array_0.data; \ + double* data1 = (double*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_BINT8) { \ - int8_t* data0 = array_0.data; \ - int8_t* data1 = array_1.data; \ + int8_t* data0 = (int8_t*) array_0.data; \ + int8_t* data1 = (int8_t*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_COMPLEX_FLOAT32) { \ - float _Complex* data0 = array_0.data; \ - float _Complex* data1 = array_1.data; \ + float _Complex* data0 = (float _Complex*) array_0.data; \ + float _Complex* data1 = (float _Complex*) array_1.data; \ data0[index_0] = data1[index_1]; \ } else if (array_0.type == BSP_COMPLEX_FLOAT64) { \ - double _Complex* data0 = array_0.data; \ - double _Complex* data1 = array_1.data; \ + double _Complex* data0 = (double _Complex*) array_0.data; \ + double _Complex* data1 = (double _Complex*) array_1.data; \ data0[index_0] = data1[index_1]; \ } \ } @@ -224,43 +226,43 @@ void bsp_destroy_array_t(bsp_array_t array) { #define bsp_array_read(array, index, value) \ { \ if (array.type == BSP_UINT8) { \ - uint8_t* data = array.data; \ + uint8_t* data = (uint8_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_UINT16) { \ - uint16_t* data = array.data; \ + uint16_t* data = (uint16_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_UINT32) { \ - uint32_t* data = array.data; \ + uint32_t* data = (uint32_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_UINT64) { \ - uint64_t* data = array.data; \ + uint64_t* data = (uint64_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_INT8) { \ - int8_t* data = array.data; \ + int8_t* data = (int8_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_INT16) { \ - int16_t* data = array.data; \ + int16_t* data = (int16_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_INT32) { \ - int32_t* data = array.data; \ + int32_t* data = (int32_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_INT64) { \ - int64_t* data = array.data; \ + int64_t* data = (int64_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_FLOAT32) { \ - float* data = array.data; \ + float* data = (float*) array.data; \ value = data[index]; \ } else if (array.type == BSP_FLOAT64) { \ - double* data = array.data; \ + double* data = (double*) array.data; \ value = data[index]; \ } else if (array.type == BSP_BINT8) { \ - int8_t* data = array.data; \ + int8_t* data = (int8_t*) array.data; \ value = data[index]; \ } else if (array.type == BSP_COMPLEX_FLOAT32) { \ - float _Complex* data = array.data; \ + float _Complex* data = (float _Complex*) array.data; \ value = data[index]; \ } else if (array.type == BSP_COMPLEX_FLOAT64) { \ - double _Complex* data = array.data; \ + double _Complex* data = (double _Complex*) array.data; \ value = data[index]; \ } \ } @@ -269,69 +271,75 @@ void bsp_destroy_array_t(bsp_array_t array) { #define bsp_array_swap(array, i, j) \ { \ if (array.type == BSP_UINT8) { \ - uint8_t* data = array.data; \ + uint8_t* data = (uint8_t*) array.data; \ uint8_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_UINT16) { \ - uint16_t* data = array.data; \ + uint16_t* data = (uint16_t*) array.data; \ uint16_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_UINT32) { \ - uint32_t* data = array.data; \ + uint32_t* data = (uint32_t*) array.data; \ uint32_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_UINT64) { \ - uint64_t* data = array.data; \ + uint64_t* data = (uint64_t*) array.data; \ uint64_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_INT8) { \ - int8_t* data = array.data; \ + int8_t* data = (int8_t*) array.data; \ int8_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_INT16) { \ - int16_t* data = array.data; \ + int16_t* data = (int16_t*) array.data; \ int16_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_INT32) { \ - int32_t* data = array.data; \ + int32_t* data = (int32_t*) array.data; \ int32_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_INT64) { \ - int64_t* data = array.data; \ + int64_t* data = (int64_t*) array.data; \ int64_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_FLOAT32) { \ - float* data = array.data; \ + float* data = (float*) array.data; \ float v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_FLOAT64) { \ - double* data = array.data; \ + double* data = (double*) array.data; \ double v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_BINT8) { \ - int8_t* data = array.data; \ + int8_t* data = (int8_t*) array.data; \ int8_t v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_COMPLEX_FLOAT32) { \ - float _Complex* data = array.data; \ + float _Complex* data = (float _Complex*) array.data; \ float _Complex v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } else if (array.type == BSP_COMPLEX_FLOAT64) { \ - double _Complex* data = array.data; \ + double _Complex* data = (double _Complex*) array.data; \ double _Complex v = data[i]; \ data[i] = data[j]; \ data[j] = v; \ } \ } + +#endif + +#ifdef __cplusplus +#include +#endif diff --git a/include/binsparse/detail/cpp/array.hpp b/include/binsparse/detail/cpp/array.hpp new file mode 100644 index 0000000..c351202 --- /dev/null +++ b/include/binsparse/detail/cpp/array.hpp @@ -0,0 +1,115 @@ +#pragma once + +#ifdef __cplusplus + +#include +#include + +namespace binsparse { + +namespace __detail { + +using array_ptr_variant_t = + std::variant; + +array_ptr_variant_t get_typed_ptr(bsp_array_t array) { + if (array.type == BSP_UINT8) { + uint8_t* data = (uint8_t*) array.data; + return data; + } else if (array.type == BSP_UINT16) { + uint16_t* data = (uint16_t*) array.data; + return data; + } else if (array.type == BSP_UINT32) { + uint32_t* data = (uint32_t*) array.data; + return data; + } else if (array.type == BSP_UINT64) { + uint64_t* data = (uint64_t*) array.data; + return data; + } else if (array.type == BSP_INT8) { + int8_t* data = (int8_t*) array.data; + return data; + } else if (array.type == BSP_INT16) { + int16_t* data = (int16_t*) array.data; + return data; + } else if (array.type == BSP_INT32) { + int32_t* data = (int32_t*) array.data; + return data; + } else if (array.type == BSP_INT64) { + int64_t* data = (int64_t*) array.data; + return data; + } else if (array.type == BSP_FLOAT32) { + float* data = (float*) array.data; + return data; + } else if (array.type == BSP_FLOAT64) { + double* data = (double*) array.data; + return data; + } else if (array.type == BSP_BINT8) { + int8_t* data = (int8_t*) array.data; + return data; + } else if (array.type == BSP_COMPLEX_FLOAT32) { + float _Complex* data = (float _Complex*) array.data; + return data; + } else if (array.type == BSP_COMPLEX_FLOAT64) { + double _Complex* data = (double _Complex*) array.data; + return data; + } + return {}; +} + +} // namespace __detail + +} // namespace binsparse + +// value = array[index] +template +void bsp_array_read(bsp_array_t array, size_t index, T& value) { + auto variant_ptr = binsparse::__detail::get_typed_ptr(array); + + std::visit( + [&](auto* ptr) { + using U = std::remove_pointer_t; + + if constexpr (std::is_assignable_v) { + value = ptr[index]; + } + }, + variant_ptr); +} + +// array[index] = value +template +void bsp_array_write(bsp_array_t array, size_t index, U value) { + auto variant_ptr = binsparse::__detail::get_typed_ptr(array); + + std::visit( + [&](auto* ptr) { + using T = std::remove_pointer_t; + + if constexpr (std::is_assignable_v) { + ptr[index] = value; + } + }, + variant_ptr); +} + +// array_0[index_0] = array_1[index_1] +void bsp_array_awrite(bsp_array_t array_0, size_t index_0, bsp_array_t array_1, + size_t index_1) { + auto variant_ptr_0 = binsparse::__detail::get_typed_ptr(array_0); + auto variant_ptr_1 = binsparse::__detail::get_typed_ptr(array_1); + + std::visit( + [&](auto* ptr_0, auto* ptr_1) { + using T = std::remove_pointer_t; + using U = std::remove_pointer_t; + + if constexpr (std::is_assignable_v) { + ptr_0[index_0] = ptr_1[index_1]; + } + }, + variant_ptr_0, variant_ptr_1); +} + +#endif diff --git a/include/binsparse/generate.h b/include/binsparse/generate.h index f3e4acc..61883a3 100644 --- a/include/binsparse/generate.h +++ b/include/binsparse/generate.h @@ -4,57 +4,57 @@ void bsp_array_fill_random(bsp_array_t array, size_t bound) { if (array.type == BSP_UINT8) { - uint8_t* values = array.data; + uint8_t* values = (uint8_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_UINT16) { - uint16_t* values = array.data; + uint16_t* values = (uint16_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_UINT32) { - uint32_t* values = array.data; + uint32_t* values = (uint32_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_UINT64) { - uint64_t* values = array.data; + uint64_t* values = (uint64_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_INT8) { - int8_t* values = array.data; + int8_t* values = (int8_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_INT16) { - int16_t* values = array.data; + int16_t* values = (int16_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_INT32) { - int32_t* values = array.data; + int32_t* values = (int32_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_INT64) { - int64_t* values = array.data; + int64_t* values = (int64_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % bound; } } else if (array.type == BSP_FLOAT32) { - float* values = array.data; + float* values = (float*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = drand48() * bound; } } else if (array.type == BSP_FLOAT64) { - double* values = array.data; + double* values = (double*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = drand48() * bound; } } else if (array.type == BSP_BINT8) { - int8_t* values = array.data; + int8_t* values = (int8_t*) array.data; for (size_t i = 0; i < array.size; i++) { values[i] = lrand48() % 2; } diff --git a/include/binsparse/hdf5_wrapper.h b/include/binsparse/hdf5_wrapper.h index 2255fc7..c08d02c 100644 --- a/include/binsparse/hdf5_wrapper.h +++ b/include/binsparse/hdf5_wrapper.h @@ -13,8 +13,12 @@ int bsp_write_array(hid_t f, char* label, bsp_array_t array, array = bsp_complex_array_to_fp(array); } + hsize_t hsize[1]; + + hsize[0] = array.size; + hid_t hdf5_standard_type = bsp_get_hdf5_standard_type(array.type); - hid_t fspace = H5Screate_simple(1, (hsize_t[]){array.size}, NULL); + hid_t fspace = H5Screate_simple(1, hsize, NULL); hid_t lcpl = H5Pcreate(H5P_LINK_CREATE); hid_t dcpl = H5Pcreate(H5P_DATASET_CREATE); @@ -27,7 +31,8 @@ int bsp_write_array(hid_t f, char* label, bsp_array_t array, chunk_size = array.size; } - H5Pset_chunk(dcpl, 1, (hsize_t[]){chunk_size}); + hsize[0] = chunk_size; + H5Pset_chunk(dcpl, 1, hsize); if (compression_level > 0) { H5Pset_deflate(dcpl, compression_level); @@ -120,7 +125,7 @@ char* bsp_read_attribute(hid_t f, char* label) { size_t size = H5Tget_size(strtype); - char* string = malloc(size + 1); + char* string = (char*) malloc(size + 1); H5Aread(attribute, strtype, string); diff --git a/include/binsparse/matrix_formats.h b/include/binsparse/matrix_formats.h index 7294b52..baeb837 100644 --- a/include/binsparse/matrix_formats.h +++ b/include/binsparse/matrix_formats.h @@ -14,30 +14,31 @@ typedef enum bsp_matrix_format_t { BSP_DCSC = 18, BSP_COO = 19, BSP_COOR = 19, - BSP_COOC = 20 + BSP_COOC = 20, + BSP_INVALID_FORMAT = 21 } bsp_matrix_format_t; char* bsp_get_matrix_format_string(bsp_matrix_format_t format) { if (format == BSP_DVEC) { - return "DVEC"; + return (char*) "DVEC"; } else if (format == BSP_DMAT) { - return "DMAT"; + return (char*) "DMAT"; } else if (format == BSP_DMATC) { - return "DMATC"; + return (char*) "DMATC"; } else if (format == BSP_CVEC) { - return "CVEC"; + return (char*) "CVEC"; } else if (format == BSP_CSR) { - return "CSR"; + return (char*) "CSR"; } else if (format == BSP_DCSR) { - return "DCSR"; + return (char*) "DCSR"; } else if (format == BSP_DCSC) { - return "DCSC"; + return (char*) "DCSC"; } else if (format == BSP_COO) { - return "COO"; + return (char*) "COO"; } else if (format == BSP_COOC) { - return "COOC"; + return (char*) "COOC"; } else { - return ""; + return (char*) ""; } } @@ -67,6 +68,6 @@ bsp_matrix_format_t bsp_get_matrix_format(char* format) { } else if (strcmp("COOC", format) == 0) { return BSP_COOC; } else { - return 0; + return BSP_INVALID_FORMAT; } } diff --git a/include/binsparse/matrix_market/matrix_market_inspector.h b/include/binsparse/matrix_market/matrix_market_inspector.h index 0e9d421..d33878c 100644 --- a/include/binsparse/matrix_market/matrix_market_inspector.h +++ b/include/binsparse/matrix_market/matrix_market_inspector.h @@ -45,7 +45,7 @@ bsp_mm_metadata bsp_mmread_metadata(char* file_path) { size_t comments_capacity = 2048; size_t comments_size = 0; - char* comments = malloc(sizeof(char) * comments_capacity); + char* comments = (char*) malloc(sizeof(char) * comments_capacity); while (!outOfComments) { char* line = fgets(buf, 2048, f); @@ -60,7 +60,7 @@ bsp_mm_metadata bsp_mmread_metadata(char* file_path) { while (comments_size + strlen(line) > comments_capacity) { comments_capacity <<= 1; } - comments = realloc(comments, sizeof(char) * comments_capacity); + comments = (char*) realloc(comments, sizeof(char) * comments_capacity); } memcpy(comments + comments_size, line, strlen(line)); diff --git a/include/binsparse/matrix_market/matrix_market_read.h b/include/binsparse/matrix_market/matrix_market_read.h index a302c45..e2e1fb3 100644 --- a/include/binsparse/matrix_market/matrix_market_read.h +++ b/include/binsparse/matrix_market/matrix_market_read.h @@ -209,7 +209,7 @@ bsp_matrix_t bsp_mmread_explicit_coordinate(char* file_path, count++; } - size_t* indices = malloc(sizeof(size_t) * matrix.nnz); + size_t* indices = (size_t*) malloc(sizeof(size_t) * matrix.nnz); for (size_t i = 0; i < matrix.nnz; i++) { indices[i] = i; diff --git a/include/binsparse/matrix_market/matrix_market_write.h b/include/binsparse/matrix_market/matrix_market_write.h index 238ee78..3446bda 100644 --- a/include/binsparse/matrix_market/matrix_market_write.h +++ b/include/binsparse/matrix_market/matrix_market_write.h @@ -13,13 +13,13 @@ void bsp_mmwrite(char* file_path, bsp_matrix_t matrix) { char* structure = NULL; if (matrix.structure == BSP_GENERAL) { - structure = "general"; + structure = (char*) "general"; } else if (matrix.structure == BSP_SYMMETRIC) { - structure = "symmetric"; + structure = (char*) "symmetric"; } else if (matrix.structure == BSP_HERMITIAN) { - structure = "hermitian"; + structure = (char*) "hermitian"; } else if (matrix.structure == BSP_SKEW_SYMMETRIC) { - structure = "skew-symmetric"; + structure = (char*) "skew-symmetric"; } else { assert(false); } @@ -33,20 +33,20 @@ void bsp_mmwrite(char* file_path, bsp_matrix_t matrix) { if (matrix.is_iso == true) { mm_type = BSP_MM_PATTERN; - type = "pattern"; + type = (char*) "pattern"; } else if ((matrix.values.type >= BSP_UINT8 && matrix.values.type <= BSP_INT64) || matrix.values.type == BSP_BINT8) { mm_type = BSP_MM_INTEGER; - type = "integer"; + type = (char*) "integer"; } else if (matrix.values.type >= BSP_FLOAT32 && matrix.values.type <= BSP_FLOAT64) { mm_type = BSP_MM_REAL; - type = "real"; + type = (char*) "real"; } else if (matrix.values.type == BSP_COMPLEX_FLOAT32 || matrix.values.type == BSP_COMPLEX_FLOAT64) { mm_type = BSP_MM_COMPLEX; - type = "complex"; + type = (char*) "complex"; } else { assert(false); } @@ -85,8 +85,8 @@ void bsp_mmwrite(char* file_path, bsp_matrix_t matrix) { bsp_array_read(matrix.indices_0, count, i); bsp_array_read(matrix.indices_1, count, j); bsp_array_read(matrix.values, count, value); - double real_value = 1.0 * value; - double complex_value = 1j * value; + double real_value = __real__ value; + double complex_value = __imag__ value; fprintf(f, "%zu %zu %.17lg %.17lg\n", i + 1, j + 1, real_value, complex_value); } else { diff --git a/include/binsparse/read_matrix.h b/include/binsparse/read_matrix.h index 1103c31..12be8fd 100644 --- a/include/binsparse/read_matrix.h +++ b/include/binsparse/read_matrix.h @@ -7,7 +7,7 @@ bsp_matrix_t bsp_read_matrix_from_group(hid_t f) { bsp_matrix_t matrix = bsp_construct_default_matrix_t(); - char* json_string = bsp_read_attribute(f, "binsparse"); + char* json_string = bsp_read_attribute(f, (char*) "binsparse"); cJSON* j = cJSON_Parse(json_string); @@ -65,7 +65,7 @@ bsp_matrix_t bsp_read_matrix_from_group(hid_t f) { assert(data_types_ != NULL); if (cJSON_HasObjectItem(data_types_, "values")) { - matrix.values = bsp_read_array(f, "values"); + matrix.values = bsp_read_array(f, (char*) "values"); cJSON* value_type = cJSON_GetObjectItemCaseSensitive(data_types_, "values"); char* type_string = cJSON_GetStringValue(value_type); @@ -81,15 +81,15 @@ bsp_matrix_t bsp_read_matrix_from_group(hid_t f) { } if (cJSON_HasObjectItem(data_types_, "indices_0")) { - matrix.indices_0 = bsp_read_array(f, "indices_0"); + matrix.indices_0 = bsp_read_array(f, (char*) "indices_0"); } if (cJSON_HasObjectItem(data_types_, "indices_1")) { - matrix.indices_1 = bsp_read_array(f, "indices_1"); + matrix.indices_1 = bsp_read_array(f, (char*) "indices_1"); } if (cJSON_HasObjectItem(data_types_, "pointers_to_1")) { - matrix.pointers_to_1 = bsp_read_array(f, "pointers_to_1"); + matrix.pointers_to_1 = bsp_read_array(f, (char*) "pointers_to_1"); } if (cJSON_HasObjectItem(binsparse, "structure")) { diff --git a/include/binsparse/structure.h b/include/binsparse/structure.h index 469b2f6..c6793c8 100644 --- a/include/binsparse/structure.h +++ b/include/binsparse/structure.h @@ -12,26 +12,27 @@ typedef enum bsp_structure_t { BSP_HERMITIAN_UPPER = 103, BSP_SKEW_SYMMETRIC = 104, BSP_SKEW_SYMMETRIC_LOWER = 104, - BSP_SKEW_SYMMETRIC_UPPER = 105 + BSP_SKEW_SYMMETRIC_UPPER = 105, + BSP_INVALID_STRUCTURE = 106 } bsp_structure_t; char* bsp_get_structure_string(bsp_structure_t structure) { if (structure == BSP_GENERAL) { - return "general"; + return (char*) "general"; } else if (structure == BSP_SYMMETRIC_LOWER) { - return "symmetric_lower"; + return (char*) "symmetric_lower"; } else if (structure == BSP_SYMMETRIC_UPPER) { - return "symmetric_upper"; + return (char*) "symmetric_upper"; } else if (structure == BSP_HERMITIAN_LOWER) { - return "hermitian_lower"; + return (char*) "hermitian_lower"; } else if (structure == BSP_HERMITIAN_UPPER) { - return "hermitian_upper"; + return (char*) "hermitian_upper"; } else if (structure == BSP_SKEW_SYMMETRIC_LOWER) { - return "skew_symmetric_lower"; + return (char*) "skew_symmetric_lower"; } else if (structure == BSP_SKEW_SYMMETRIC_UPPER) { - return "skew_symmetric_upper"; + return (char*) "skew_symmetric_upper"; } else { - return ""; + return (char*) ""; } } @@ -49,6 +50,6 @@ bsp_structure_t bsp_get_structure(char* structure) { } else if (strcmp(structure, "skew_symmetric_upper") == 0) { return BSP_SKEW_SYMMETRIC_UPPER; } else { - return BSP_SKEW_SYMMETRIC_UPPER + 100; + return BSP_INVALID_STRUCTURE; } } diff --git a/include/binsparse/types.h b/include/binsparse/types.h index 8578957..386d75c 100644 --- a/include/binsparse/types.h +++ b/include/binsparse/types.h @@ -16,38 +16,39 @@ typedef enum bsp_type_t { BSP_FLOAT64 = 9, BSP_BINT8 = 10, BSP_COMPLEX_FLOAT32 = 11, - BSP_COMPLEX_FLOAT64 = 12 + BSP_COMPLEX_FLOAT64 = 12, + BSP_INVALID_TYPE = 13 } bsp_type_t; char* bsp_get_type_string(bsp_type_t type) { if (type == BSP_UINT8) { - return "uint8"; + return (char*) "uint8"; } else if (type == BSP_UINT16) { - return "uint16"; + return (char*) "uint16"; } else if (type == BSP_UINT32) { - return "uint32"; + return (char*) "uint32"; } else if (type == BSP_UINT64) { - return "uint64"; + return (char*) "uint64"; } else if (type == BSP_INT8) { - return "int8"; + return (char*) "int8"; } else if (type == BSP_INT16) { - return "int16"; + return (char*) "int16"; } else if (type == BSP_INT32) { - return "int32"; + return (char*) "int32"; } else if (type == BSP_INT64) { - return "int64"; + return (char*) "int64"; } else if (type == BSP_FLOAT32) { - return "float32"; + return (char*) "float32"; } else if (type == BSP_FLOAT64) { - return "float64"; + return (char*) "float64"; } else if (type == BSP_BINT8) { - return "bint8"; + return (char*) "bint8"; } else if (type == BSP_COMPLEX_FLOAT32) { - return "complex[float32]"; + return (char*) "complex[float32]"; } else if (type == BSP_COMPLEX_FLOAT64) { - return "complex[float64]"; + return (char*) "complex[float64]"; } else { - return ""; + return (char*) ""; } } @@ -128,7 +129,7 @@ bsp_type_t bsp_get_bsp_type(hid_t type) { } else if (size == 8) { return BSP_UINT64; } else { - return H5I_INVALID_HID; + return BSP_INVALID_TYPE; } } else /* if (sign == H5T_SGN_2) */ { if (size == 1) { @@ -140,7 +141,7 @@ bsp_type_t bsp_get_bsp_type(hid_t type) { } else if (size == 8) { return BSP_INT64; } else { - return H5I_INVALID_HID; + return BSP_INVALID_TYPE; } } } else if (cl == H5T_FLOAT) { @@ -149,10 +150,10 @@ bsp_type_t bsp_get_bsp_type(hid_t type) { } else if (size == 8) { return BSP_FLOAT64; } else { - return H5I_INVALID_HID; + return BSP_INVALID_TYPE; } } else { - return H5I_INVALID_HID; + return BSP_INVALID_TYPE; } } diff --git a/include/binsparse/write_matrix.h b/include/binsparse/write_matrix.h index 99ad325..0bd3657 100644 --- a/include/binsparse/write_matrix.h +++ b/include/binsparse/write_matrix.h @@ -83,29 +83,30 @@ char* bsp_generate_json(bsp_matrix_t matrix, cJSON* user_json) { int bsp_write_matrix_to_group(hid_t f, bsp_matrix_t matrix, cJSON* user_json, int compression_level) { - int result = bsp_write_array(f, "values", matrix.values, compression_level); + int result = + bsp_write_array(f, (char*) "values", matrix.values, compression_level); if (result != 0) return result; if (matrix.indices_0.size > 0) { - result = - bsp_write_array(f, "indices_0", matrix.indices_0, compression_level); + result = bsp_write_array(f, (char*) "indices_0", matrix.indices_0, + compression_level); if (result != 0) { return result; } } if (matrix.indices_1.size > 0) { - result = - bsp_write_array(f, "indices_1", matrix.indices_1, compression_level); + result = bsp_write_array(f, (char*) "indices_1", matrix.indices_1, + compression_level); if (result != 0) { return result; } } if (matrix.pointers_to_1.size > 0) { - result = bsp_write_array(f, "pointers_to_1", matrix.pointers_to_1, + result = bsp_write_array(f, (char*) "pointers_to_1", matrix.pointers_to_1, compression_level); if (result != 0) { return result; @@ -114,7 +115,7 @@ int bsp_write_matrix_to_group(hid_t f, bsp_matrix_t matrix, cJSON* user_json, char* json_string = bsp_generate_json(matrix, user_json); - bsp_write_attribute(f, "binsparse", json_string); + bsp_write_attribute(f, (char*) "binsparse", json_string); free(json_string); return 0;