17 template <
typename T,
typename indexT,
bool columnMajor>
21 template <
typename T,
typename indexT,
bool columnMajor>
25 template <
typename T,
typename indexT,
bool columnMajor>
29 template <
typename T,
typename indexT,
bool columnMajor>
33 template <
typename T,
typename indexT,
bool columnMajor>
37 template <
typename T,
typename indexT,
bool columnMajor>
40 if (valueSizes ==
nullptr) {
return 0; }
41 return valueSizes[vec];
45 template <
typename T,
typename indexT,
bool columnMajor>
48 if (indexSizes ==
nullptr) {
return 0; }
49 return indexSizes[vec];
53 template <
typename T,
typename indexT,
bool columnMajor>
59 template <
typename T,
typename indexT,
bool columnMajor>
63 FILE *fp = fopen(filename,
"wb");
66 fwrite(metadata, 1, NUM_META_DATA *
sizeof(uint32_t), fp);
69 for (uint32_t i = 0; i < outerDim; ++i) { fwrite(&valueSizes[i], 1,
sizeof(indexT), fp); }
70 for (uint32_t i = 0; i < outerDim; ++i) { fwrite(&indexSizes[i], 1,
sizeof(indexT), fp); }
73 for (uint32_t i = 0; i < outerDim; ++i) { fwrite(values[i], 1, valueSizes[i] *
sizeof(T), fp); }
76 for (uint32_t i = 0; i < outerDim; ++i) { fwrite(counts[i], 1, valueSizes[i] *
sizeof(indexT), fp); }
79 for (uint32_t i = 0; i < outerDim; ++i) { fwrite(indices[i], 1, indexSizes[i] *
sizeof(indexT), fp); }
86 template <
typename T,
typename indexT,
bool columnMajor>
89 std::cout << std::endl;
90 std::cout <<
"IVSparse Matrix" << std::endl;
93 if (numRows < 100 && numCols < 100)
96 for (uint32_t i = 0; i < numRows; i++)
98 for (uint32_t j = 0; j < numCols; j++)
100 std::cout <<
coeff(i, j) <<
" ";
102 std::cout << std::endl;
105 else if (numRows > 100 && numCols > 100)
108 for (uint32_t i = 0; i < 100; i++)
110 for (uint32_t j = 0; j < 100; j++)
112 std::cout <<
coeff(i, j) <<
" ";
114 std::cout << std::endl;
118 std::cout << std::endl;
122 template <
typename T,
typename indexT,
bool columnMajor>
126 Eigen::SparseMatrix<T, columnMajor ? Eigen::ColMajor : Eigen::RowMajor> eigenMatrix(numRows, numCols);
129 for (uint32_t i = 0; i < outerDim; ++i)
134 eigenMatrix.insert(it.row(), it.col()) = it.value();
139 eigenMatrix.makeCompressed();
149 template <
typename T,
typename indexT,
bool columnMajor>
154 T *values = (T *)malloc(nnz *
sizeof(T));
155 indexT *indices = (indexT *)malloc(nnz *
sizeof(indexT));
156 indexT *colPtrs = (indexT *)malloc((outerDim + 1) *
sizeof(indexT));
161 std::map<indexT, T> dict[outerDim];
164 for (uint32_t i = 0; i < outerDim; ++i)
170 dict[i][it.getIndex()] = it.value();
173 colPtrs[i + 1] = colPtrs[i] + count;
178 for (uint32_t i = 0; i < outerDim; ++i)
180 for (
auto &pair : dict[i])
182 values[count] = pair.second;
183 indices[count] = pair.first;
200 template <
typename T,
typename indexT,
bool columnMajor>
206 assert(outerDim > 0 &&
"Cannot convert an empty matrix to an Eigen matrix!");
210 Eigen::SparseMatrix<T, columnMajor ? Eigen::ColMajor : Eigen::RowMajor> eigenMatrix(numRows, numCols);
213 for (uint32_t i = 0; i < outerDim; ++i)
218 eigenMatrix.insert(it.row(), it.col()) = it.value();
223 eigenMatrix.makeCompressed();
232 template <
typename T,
typename indexT,
bool columnMajor>
236 if (numRows < 1 && numCols < 1) [[unlikely]]
257 metadata[2] = outerDim;
262 values = (T **)realloc(values, outerDim *
sizeof(T *));
263 counts = (indexT **)realloc(counts, outerDim *
sizeof(indexT *));
264 indices = (indexT **)realloc(indices, outerDim *
sizeof(indexT *));
265 valueSizes = (indexT *)realloc(valueSizes, outerDim *
sizeof(indexT));
266 indexSizes = (indexT *)realloc(indexSizes, outerDim *
sizeof(indexT));
268 catch (std::bad_alloc &e)
270 std::cerr <<
"Error: " << e.what() << std::endl;
275 values[outerDim - 1] =
nullptr;
276 counts[outerDim - 1] =
nullptr;
277 indices[outerDim - 1] =
nullptr;
278 valueSizes[outerDim - 1] = 0;
279 indexSizes[outerDim - 1] = 0;
288 if ((vec.getLength() != innerDim))
289 throw std::invalid_argument(
"The vector must be the same size as the outer dimension of the matrix!");
304 metadata[2] = outerDim;
310 values = (T **)realloc(values, outerDim *
sizeof(T *));
311 counts = (indexT **)realloc(counts, outerDim *
sizeof(indexT *));
312 indices = (indexT **)realloc(indices, outerDim *
sizeof(indexT *));
313 valueSizes = (indexT *)realloc(valueSizes, outerDim *
sizeof(indexT));
314 indexSizes = (indexT *)realloc(indexSizes, outerDim *
sizeof(indexT));
316 catch (std::bad_alloc &e)
318 std::cerr <<
"Error: " << e.what() << std::endl;
323 valueSizes[outerDim - 1] = vec.uniqueVals();
324 indexSizes[outerDim - 1] = vec.
nonZeros();
329 values[outerDim - 1] = (T *)malloc(valueSizes[outerDim - 1] *
sizeof(T));
330 counts[outerDim - 1] = (indexT *)malloc(
sizeof(indexT) * valueSizes[outerDim - 1]);
331 indices[outerDim - 1] = (indexT *)malloc(indexSizes[outerDim - 1] *
sizeof(indexT));
333 catch (std::bad_alloc &e)
335 std::cerr <<
"Error: " << e.what() << std::endl;
340 memcpy(values[outerDim - 1], vec.getValues(), valueSizes[outerDim - 1] *
sizeof(T));
341 memcpy(counts[outerDim - 1], vec.getCounts(), valueSizes[outerDim - 1] *
sizeof(indexT));
342 memcpy(indices[outerDim - 1], vec.getIndices(), indexSizes[outerDim - 1] *
sizeof(indexT));
352 template <
typename T,
typename indexT,
bool columnMajor>
356 std::unordered_map<T, std::vector<indexT>> mapsT[innerDim];
359 for (uint32_t i = 0; i < outerDim; ++i)
364 if constexpr (columnMajor)
366 mapsT[it.row()][it.value()].push_back(it.col());
370 mapsT[it.col()][it.value()].push_back(it.row());
383 template <
typename T,
typename indexT,
bool columnMajor>
388 std::unordered_map<T, std::vector<indexT>> mapsT[innerDim];
391 for (uint32_t i = 0; i < outerDim; ++i)
396 if constexpr (columnMajor)
398 mapsT[it.row()][it.value()].push_back(it.col());
402 mapsT[it.col()][it.value()].push_back(it.row());
412 template <
typename T,
typename indexT,
bool columnMajor>
416 assert(start < outerDim && end <= outerDim && start < end &&
"Invalid start and end values!");
420 std::vector<typename IVSparse::SparseMatrix<T, indexT, 2, columnMajor>::Vector> vecs(end - start);
423 for (uint32_t i = start; i < end; ++i)
429 vecs[i - start] = temp;
Definition: IVCSC_Iterator.hpp:25
Definition: CSC_SparseMatrix.hpp:24
Definition: VCSC_SparseMatrix.hpp:22
uint32_t nonZeros() const
Definition: IVSparse_Base_Methods.hpp:34
Definition: IVCSC_SparseMatrix.hpp:27
IVSparse::SparseMatrix< T, indexT, compressionLevel, columnMajor >::Vector getVector(uint32_t vec)
Definition: IVCSC_Methods.hpp:29
IVSparse::SparseMatrix< T, indexT, compressionLevel, columnMajor > transpose()
Definition: IVCSC_Methods.hpp:269
void append(typename SparseMatrix< T, indexT, compressionLevel, columnMajor >::Vector &vec)
Definition: IVCSC_Methods.hpp:202
IVSparse::SparseMatrix< T, indexT, 1, columnMajor > toCSC()
Definition: IVCSC_Methods.hpp:92
T coeff(uint32_t row, uint32_t col)
Definition: IVCSC_Methods.hpp:17
void write(const char *filename)
Definition: IVCSC_Methods.hpp:42
void print()
Definition: IVCSC_Methods.hpp:64
Eigen::SparseMatrix< T, columnMajor ? Eigen::ColMajor :Eigen::RowMajor > toEigen()
Definition: IVCSC_Methods.hpp:169
bool isColumnMajor() const
Definition: IVCSC_Methods.hpp:21
std::vector< typename IVSparse::SparseMatrix< T, indexT, compressionLevel, columnMajor >::Vector > slice(uint32_t start, uint32_t end)
Definition: IVCSC_Methods.hpp:350
void inPlaceTranspose()
Definition: IVCSC_Methods.hpp:311