int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J,
double **val, MM_typecode *matcode)
{
int ret_code;
FILE *f;
if (strcmp(fname, "stdin") == 0) f=stdin;
else
if ((f = fopen(fname, "r")) == NULL)
return MM_COULD_NOT_READ_FILE;
if ((ret_code = mm_read_banner(f, matcode)) != 0)
return ret_code;
if (!(mm_is_valid(*matcode) && mm_is_sparse(*matcode) &&
mm_is_matrix(*matcode)))
return MM_UNSUPPORTED_TYPE;
if ((ret_code = mm_read_mtx_crd_size(f, M, N, nz)) != 0)
return ret_code;
//*I = (int *) malloc(*nz * sizeof(int));
//*J = (int *) malloc(*nz * sizeof(int));
//*val = NULL;
*I = new int[*nz];
*J = new int[*nz];
*val = 0;
if (mm_is_complex(*matcode))
{
//*val = (double *) malloc(*nz * 2 * sizeof(double));
*val = new double[2*(*nz)];
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
else if (mm_is_real(*matcode))
{
//*val = (double *) malloc(*nz * sizeof(double));
*val = new double[*nz];
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
else if (mm_is_pattern(*matcode))
{
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
if (f != stdin) fclose(f);
return 0;
}
int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J,
double **val, MM_typecode *matcode)
{
int ret_code;
ZOLTAN_FILE* f;
if ((f = ZOLTAN_FILE_open(fname, "r", STANDARD)) == NULL)
return MM_COULD_NOT_READ_FILE;
if ((ret_code = mm_read_banner(f, matcode)) != 0)
return ret_code;
if (!(mm_is_valid(*matcode) && mm_is_sparse(*matcode) &&
mm_is_matrix(*matcode)))
return MM_UNSUPPORTED_TYPE;
if ((ret_code = mm_read_mtx_crd_size(f, M, N, nz)) != 0)
return ret_code;
*I = (int *) malloc(*nz * sizeof(int));
*J = (int *) malloc(*nz * sizeof(int));
*val = NULL;
if (mm_is_complex(*matcode))
{
*val = (double *) malloc(*nz * 2 * sizeof(double));
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
else if (mm_is_real(*matcode))
{
*val = (double *) malloc(*nz * sizeof(double));
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
else if (mm_is_pattern(*matcode))
{
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
ZOLTAN_FILE_close(f);
return 0;
}
/* fread sparse */
static mm_sparse *
mm_real_fread_sparse (FILE *fp, MM_typecode typecode)
{
int k, l;
int m, n, nnz;
int *j;
mm_sparse *s;
if (mm_read_mtx_crd_size (fp, &m, &n, &nnz) != 0) return NULL;
s = mm_real_new (MM_REAL_SPARSE, MM_REAL_GENERAL, m, n, nnz);
j = (int *) malloc (s->nnz * sizeof (int));
if (mm_read_mtx_crd_data (fp, s->m, s->n, s->nnz, s->i, j, s->data, typecode) != 0) {
free (j);
mm_real_free (s);
return NULL;
}
l = 0;
for (k = 0; k < nnz; k++) {
s->i[k]--; // fortran -> c
while (l < j[k]) s->p[l++] = k;
}
while (l <= n) s->p[l++] = k;
if (mm_is_symmetric (typecode)) {
mm_real_set_symmetric (s);
for (k = 0; k < nnz; k++) {
if (s->i[k] == j[k] - 1) continue;
(s->i[k] < j[k] - 1) ? mm_real_set_upper (s) : mm_real_set_lower (s);
break;
}
}
free (j);
return s;
}
cs *read_matrix(const char *filename, MM_typecode &matcode)
{
LogInfo("Reading Matrix from " << std::string(filename) << "\n");
FILE *file = fopen(filename, "r");
if (!file)
{
LogError("Error: Cannot read file " << std::string(filename) << "\n");
return NULL;
}
LogInfo("Reading Matrix Market banner...");
if (mm_read_banner(file, &matcode) != 0)
{
LogError("Error: Could not process Matrix Market banner\n");
fclose(file);
return NULL;
}
if (!mm_is_matrix(matcode) || !mm_is_sparse(matcode)
|| mm_is_complex(matcode))
{
LogError(
"Error: Unsupported matrix format - Must be real and sparse\n");
fclose(file);
return NULL;
}
Int M, N, nz;
if ((mm_read_mtx_crd_size(file, &M, &N, &nz)) != 0)
{
LogError("Error: Could not parse matrix dimension and size.\n");
fclose(file);
return NULL;
}
if (M != N)
{
LogError("Error: Matrix must be square.\n");
fclose(file);
return NULL;
}
LogInfo("Reading matrix data...\n");
Int *I = (Int *)SuiteSparse_malloc(static_cast<size_t>(nz), sizeof(Int));
Int *J = (Int *)SuiteSparse_malloc(static_cast<size_t>(nz), sizeof(Int));
double *val
= (double *)SuiteSparse_malloc(static_cast<size_t>(nz), sizeof(double));
if (!I || !J || !val)
{
LogError("Error: Ran out of memory in Mongoose::read_matrix\n");
SuiteSparse_free(I);
SuiteSparse_free(J);
SuiteSparse_free(val);
fclose(file);
return NULL;
}
mm_read_mtx_crd_data(file, M, N, nz, I, J, val, matcode);
fclose(file); // Close the file
for (Int k = 0; k < nz; k++)
{
--I[k];
--J[k];
if (mm_is_pattern(matcode))
val[k] = 1;
}
cs *A = (cs *)SuiteSparse_malloc(1, sizeof(cs));
if (!A)
{
LogError("Error: Ran out of memory in Mongoose::read_matrix\n");
SuiteSparse_free(I);
SuiteSparse_free(J);
SuiteSparse_free(val);
return NULL;
}
A->nzmax = nz;
A->m = M;
A->n = N;
A->p = J;
A->i = I;
A->x = val;
A->nz = nz;
LogInfo("Compressing matrix from triplet to CSC format...\n");
cs *compressed_A = cs_compress(A);
cs_spfree(A);
if (!compressed_A)
{
LogError("Error: Ran out of memory in Mongoose::read_matrix\n");
return NULL;
}
return compressed_A;
}
int mm_read_mtx_crd(char *fname, int *M, int *N, int *nz, int **I, int **J,
double **val, MM_typecode *matcode)
/******************************************************************************/
/*
Purpose:
MM_READ_MTX_CRD reads the values in an MM coordinate file.
Discussion:
This function allocates the storage for the arrays.
Modified:
31 October 2008
Parameters:
*/
/*
mm_read_mtx_crd() fills M, N, nz, array of values, and return
type code, e.g. 'MCRS'
if matrix is complex, values[] is of size 2*nz,
(nz pairs of real/imaginary values)
*/
{
int ret_code;
FILE *f;
if (strcmp(fname, "stdin") == 0) f=stdin;
else
if ((f = fopen(fname, "r")) == NULL)
return MM_COULD_NOT_READ_FILE;
if ((ret_code = mm_read_banner(f, matcode)) != 0)
return ret_code;
if (!(mm_is_valid(*matcode) && mm_is_sparse(*matcode) &&
mm_is_matrix(*matcode)))
return MM_UNSUPPORTED_TYPE;
if ((ret_code = mm_read_mtx_crd_size(f, M, N, nz)) != 0)
return ret_code;
*I = (int *) malloc(*nz * sizeof(int));
*J = (int *) malloc(*nz * sizeof(int));
*val = NULL;
if (mm_is_complex(*matcode))
{
*val = (double *) malloc(*nz * 2 * sizeof(double));
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
else if (mm_is_real(*matcode))
{
*val = (double *) malloc(*nz * sizeof(double));
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
else if (mm_is_pattern(*matcode))
{
ret_code = mm_read_mtx_crd_data(f, *M, *N, *nz, *I, *J, *val,
*matcode);
if (ret_code != 0) return ret_code;
}
if (f != stdin) fclose(f);
return 0;
}
