trunk/mmio/mmio.c

/* 
*   Matrix Market I/O library for ANSI C
*
*   See http://math.nist.gov/MatrixMarket for details.
*
*
*/


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#include "mmio.h"

int mm_read_unsymmetric_sparse(const char *fname, int *M_, int *N_, int *nz_,
                double **val_, int **I_, int **J_)
{
    FILE *f;
    MM_typecode matcode;
    int M, N, nz;
    int i;
    double *val;
    int *I, *J;
 
    if ((f = fopen(fname, "r")) == NULL)
            return -1;
 
 
    if (mm_read_banner(f, &matcode) != 0)
    {
        printf("mm_read_unsymetric: Could not process Matrix Market banner ");
        printf(" in file [%s]\n", fname);
        return -1;
    }
 
 
    if ( !(mm_is_real(matcode) && mm_is_matrix(matcode) &&
            mm_is_sparse(matcode)))
    {
        fprintf(stderr, "Sorry, this application does not support ");
        fprintf(stderr, "Market Market type: [%s]\n",
                mm_typecode_to_str(matcode));
        return -1;
    }
 
    /* find out size of sparse matrix: M, N, nz .... */
 
    if (mm_read_mtx_crd_size(f, &M, &N, &nz) !=0)
    {
        fprintf(stderr, "read_unsymmetric_sparse(): could not parse matrix size.\n");
        return -1;
    }
 
    *M_ = M;
    *N_ = N;
    *nz_ = nz;
 
    /* reseve memory for matrices */
 
    I = (int *) malloc(nz * sizeof(int));
    J = (int *) malloc(nz * sizeof(int));
    val = (double *) malloc(nz * sizeof(double));
 
    *val_ = val;
    *I_ = I;
    *J_ = J;
 
    /* NOTE: when reading in doubles, ANSI C requires the use of the "l"  */
    /*   specifier as in "%lg", "%lf", "%le", otherwise errors will occur */
    /*  (ANSI C X3.159-1989, Sec. 4.9.6.2, p. 136 lines 13-15)            */
 
    for (i=0; i<nz; i++)
    {
        fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i]);
        I[i]--;  /* adjust from 1-based to 0-based */
        J[i]--;
    }
    fclose(f);
 
    return 0;
}

int mm_is_valid(MM_typecode matcode)
{
    if (!mm_is_matrix(matcode)) return 0;
    if (mm_is_dense(matcode) && mm_is_pattern(matcode)) return 0;
    if (mm_is_real(matcode) && mm_is_hermitian(matcode)) return 0;
    if (mm_is_pattern(matcode) && (mm_is_hermitian(matcode) || 
                mm_is_skew(matcode))) return 0;
    return 1;
}

int mm_read_banner(FILE *f, MM_typecode *matcode)
{
    char line[MM_MAX_LINE_LENGTH];
    char banner[MM_MAX_TOKEN_LENGTH];
    char mtx[MM_MAX_TOKEN_LENGTH]; 
    char crd[MM_MAX_TOKEN_LENGTH];
    char data_type[MM_MAX_TOKEN_LENGTH];
    char storage_scheme[MM_MAX_TOKEN_LENGTH];
    char *p;


    mm_clear_typecode(matcode);  

    if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL) 
        return MM_PREMATURE_EOF;

    if (sscanf(line, "%s %s %s %s %s", banner, mtx, crd, data_type, 
        storage_scheme) != 5)
        return MM_PREMATURE_EOF;

    for (p=mtx; *p!='\0'; *p=tolower(*p),p++);  /* convert to lower case */
    for (p=crd; *p!='\0'; *p=tolower(*p),p++);  
    for (p=data_type; *p!='\0'; *p=tolower(*p),p++);
    for (p=storage_scheme; *p!='\0'; *p=tolower(*p),p++);

    /* check for banner */
    if (strncmp(banner, MatrixMarketBanner, strlen(MatrixMarketBanner)) != 0)
        return MM_NO_HEADER;

    /* first field should be "mtx" */
    if (strcmp(mtx, MM_MTX_STR) != 0)
        return  MM_UNSUPPORTED_TYPE;
    mm_set_matrix(matcode);


    /* second field describes whether this is a sparse matrix (in coordinate
            storgae) or a dense array */


    if (strcmp(crd, MM_SPARSE_STR) == 0)
        mm_set_sparse(matcode);
    else
    if (strcmp(crd, MM_DENSE_STR) == 0)
            mm_set_dense(matcode);
    else
        return MM_UNSUPPORTED_TYPE;
    

    /* third field */

    if (strcmp(data_type, MM_REAL_STR) == 0)
        mm_set_real(matcode);
    else
    if (strcmp(data_type, MM_COMPLEX_STR) == 0)
        mm_set_complex(matcode);
    else
    if (strcmp(data_type, MM_PATTERN_STR) == 0)
        mm_set_pattern(matcode);
    else
    if (strcmp(data_type, MM_INT_STR) == 0)
        mm_set_integer(matcode);
    else
        return MM_UNSUPPORTED_TYPE;
    

    /* fourth field */

    if (strcmp(storage_scheme, MM_GENERAL_STR) == 0)
        mm_set_general(matcode);
    else
    if (strcmp(storage_scheme, MM_SYMM_STR) == 0)
        mm_set_symmetric(matcode);
    else
    if (strcmp(storage_scheme, MM_HERM_STR) == 0)
        mm_set_hermitian(matcode);
    else
    if (strcmp(storage_scheme, MM_SKEW_STR) == 0)
        mm_set_skew(matcode);
    else
        return MM_UNSUPPORTED_TYPE;
        

    return 0;
}

int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz)
{
    if (fprintf(f, "%d %d %d\n", M, N, nz) != 3)
        return MM_COULD_NOT_WRITE_FILE;
    else 
        return 0;
}

int mm_read_mtx_crd_size(FILE *f, int *M, int *N, int *nz )
{
    char line[MM_MAX_LINE_LENGTH];
    int num_items_read;

    /* set return null parameter values, in case we exit with errors */
    *M = *N = *nz = 0;

    /* now continue scanning until you reach the end-of-comments */
    do 
    {
        if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
            return MM_PREMATURE_EOF;
    }while (line[0] == '%');

    /* line[] is either blank or has M,N, nz */
    if (sscanf(line, "%d %d %d", M, N, nz) == 3)
        return 0;
        
    else
    do
    { 
        num_items_read = fscanf(f, "%d %d %d", M, N, nz); 
        if (num_items_read == EOF) return MM_PREMATURE_EOF;
    }
    while (num_items_read != 3);

    return 0;
}


int mm_read_mtx_array_size(FILE *f, int *M, int *N)
{
    char line[MM_MAX_LINE_LENGTH];
    int num_items_read;
    /* set return null parameter values, in case we exit with errors */
    *M = *N = 0;
    
    /* now continue scanning until you reach the end-of-comments */
    do 
    {
        if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL) 
            return MM_PREMATURE_EOF;
    }while (line[0] == '%');

    /* line[] is either blank or has M,N, nz */
    if (sscanf(line, "%d %d", M, N) == 2)
        return 0;
        
    else /* we have a blank line */
    do
    { 
        num_items_read = fscanf(f, "%d %d", M, N); 
        if (num_items_read == EOF) return MM_PREMATURE_EOF;
    }
    while (num_items_read != 2);

    return 0;
}

int mm_write_mtx_array_size(FILE *f, int M, int N)
{
    if (fprintf(f, "%d %d\n", M, N) != 2)
        return MM_COULD_NOT_WRITE_FILE;
    else 
        return 0;
}


/*-------------------------------------------------------------------------*/

/******************************************************************/
/* use when I[], J[], and val[]J, and val[] are already allocated */
/******************************************************************/

int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[],
        double val[], MM_typecode matcode)
{
    int i;
    if (mm_is_complex(matcode))
    {
        for (i=0; i<nz; i++)
            if (fscanf(f, "%d %d %lg %lg", &I[i], &J[i], &val[2*i], &val[2*i+1])
                != 4) return MM_PREMATURE_EOF;
    }
    else if (mm_is_real(matcode))
    {
        for (i=0; i<nz; i++)
        {
            if (fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i])
                != 3) return MM_PREMATURE_EOF;

        }
    }

    else if (mm_is_pattern(matcode))
    {
        for (i=0; i<nz; i++)
            if (fscanf(f, "%d %d", &I[i], &J[i])
                != 2) return MM_PREMATURE_EOF;
    }
    else
        return MM_UNSUPPORTED_TYPE;

    return 0;
        
}

int mm_read_mtx_crd_entry(FILE *f, int *I, int *J,
        double *real, double *imag, MM_typecode matcode)
{
    if (mm_is_complex(matcode))
    {
            if (fscanf(f, "%d %d %lg %lg", I, J, real, imag)
                != 4) return MM_PREMATURE_EOF;
    }
    else if (mm_is_real(matcode))
    {
            if (fscanf(f, "%d %d %lg\n", I, J, real)
                != 3) return MM_PREMATURE_EOF;

    }

    else if (mm_is_pattern(matcode))
    {
            if (fscanf(f, "%d %d", I, J) != 2) return MM_PREMATURE_EOF;
    }
    else
        return MM_UNSUPPORTED_TYPE;

    return 0;
        
}


/************************************************************************
    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 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;

    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;
}

int mm_write_banner(FILE *f, MM_typecode matcode)
{
    char *str = mm_typecode_to_str(matcode);
    int ret_code;

    ret_code = fprintf(f, "%s %s\n", MatrixMarketBanner, str);
    free(str);
    if (ret_code !=2 )
        return MM_COULD_NOT_WRITE_FILE;
    else
        return 0;
}

int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[],
        double val[], MM_typecode matcode)
{
    FILE *f;
    int i;

    if (strcmp(fname, "stdout") == 0) 
        f = stdout;
    else
    if ((f = fopen(fname, "w")) == NULL)
        return MM_COULD_NOT_WRITE_FILE;
    
    /* print banner followed by typecode */
    fprintf(f, "%s ", MatrixMarketBanner);
    fprintf(f, "%s\n", mm_typecode_to_str(matcode));

    /* print matrix sizes and nonzeros */
    fprintf(f, "%d %d %d\n", M, N, nz);

    /* print values */
    if (mm_is_pattern(matcode))
        for (i=0; i<nz; i++)
            fprintf(f, "%d %d\n", I[i], J[i]);
    else
    if (mm_is_real(matcode))
        for (i=0; i<nz; i++)
            fprintf(f, "%d %d %20.16g\n", I[i], J[i], val[i]);
    else
    if (mm_is_complex(matcode))
        for (i=0; i<nz; i++)
            fprintf(f, "%d %d %20.16g %20.16g\n", I[i], J[i], val[2*i], 
                        val[2*i+1]);
    else
    {
        if (f != stdout) fclose(f);
        return MM_UNSUPPORTED_TYPE;
    }

    if (f !=stdout) fclose(f);

    return 0;
}
  

/**
*  Create a new copy of a string s.  strdup() is a common routine, but
*  not part of ANSI C, so it is included here.  Used by mm_typecode_to_str().
*
*/
char *strdup(const char *s)
{
    int len = strlen(s);
    char *s2 = (char *) malloc((len+1)*sizeof(char));
    return strcpy(s2, s);
}

char  *mm_typecode_to_str(MM_typecode matcode)
{
    char buffer[MM_MAX_LINE_LENGTH];
    char *types[4];
    char *strdup(const char *);
    int error =0;

    /* check for MTX type */
    if (mm_is_matrix(matcode)) 
        types[0] = MM_MTX_STR;
    else
        error=1;

    /* check for CRD or ARR matrix */
    if (mm_is_sparse(matcode))
        types[1] = MM_SPARSE_STR;
    else
    if (mm_is_dense(matcode))
        types[1] = MM_DENSE_STR;
    else
        return NULL;

    /* check for element data type */
    if (mm_is_real(matcode))
        types[2] = MM_REAL_STR;
    else
    if (mm_is_complex(matcode))
        types[2] = MM_COMPLEX_STR;
    else
    if (mm_is_pattern(matcode))
        types[2] = MM_PATTERN_STR;
    else
    if (mm_is_integer(matcode))
        types[2] = MM_INT_STR;
    else
        return NULL;


    /* check for symmetry type */
    if (mm_is_general(matcode))
        types[3] = MM_GENERAL_STR;
    else
    if (mm_is_symmetric(matcode))
        types[3] = MM_SYMM_STR;
    else 
    if (mm_is_hermitian(matcode))
        types[3] = MM_HERM_STR;
    else 
    if (mm_is_skew(matcode))
        types[3] = MM_SKEW_STR;
    else
        return NULL;

    sprintf(buffer,"%s %s %s %s", types[0], types[1], types[2], types[3]);
    return strdup(buffer);

}
1	johnpye	993	/*
2			* Matrix Market I/O library for ANSI C
3			*
4			* See http://math.nist.gov/MatrixMarket for details.
5			*
6			*
7			*/
8
9
10			#include <stdio.h>
11			#include <string.h>
12	jpye	1660	#include <stdlib.h>
13	johnpye	993	#include <ctype.h>
14
15			#include "mmio.h"
16
17			int mm_read_unsymmetric_sparse(const char fname, int M_, int N_, int nz_,
18			double val_, int I_, int **J_)
19			{
20			FILE *f;
21			MM_typecode matcode;
22			int M, N, nz;
23			int i;
24			double *val;
25			int I, J;
26
27			if ((f = fopen(fname, "r")) == NULL)
28			return -1;
29
30
31			if (mm_read_banner(f, &matcode) != 0)
32			{
33			printf("mm_read_unsymetric: Could not process Matrix Market banner ");
34			printf(" in file [%s]\n", fname);
35			return -1;
36			}
37
38
39
40			if ( !(mm_is_real(matcode) && mm_is_matrix(matcode) &&
41			mm_is_sparse(matcode)))
42			{
43			fprintf(stderr, "Sorry, this application does not support ");
44			fprintf(stderr, "Market Market type: [%s]\n",
45			mm_typecode_to_str(matcode));
46			return -1;
47			}
48
49			/* find out size of sparse matrix: M, N, nz .... */
50
51			if (mm_read_mtx_crd_size(f, &M, &N, &nz) !=0)
52			{
53			fprintf(stderr, "read_unsymmetric_sparse(): could not parse matrix size.\n");
54			return -1;
55			}
56
57			*M_ = M;
58			*N_ = N;
59			*nz_ = nz;
60
61			/* reseve memory for matrices */
62
63			I = (int ) malloc(nz sizeof(int));
64			J = (int ) malloc(nz sizeof(int));
65			val = (double ) malloc(nz sizeof(double));
66
67			*val_ = val;
68			*I_ = I;
69			*J_ = J;
70
71			/* NOTE: when reading in doubles, ANSI C requires the use of the "l" */
72			/* specifier as in "%lg", "%lf", "%le", otherwise errors will occur */
73			/* (ANSI C X3.159-1989, Sec. 4.9.6.2, p. 136 lines 13-15) */
74
75			for (i=0; i<nz; i++)
76			{
77			fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i]);
78			I[i]--; /* adjust from 1-based to 0-based */
79			J[i]--;
80			}
81			fclose(f);
82
83			return 0;
84			}
85
86			int mm_is_valid(MM_typecode matcode)
87			{
88			if (!mm_is_matrix(matcode)) return 0;
89			if (mm_is_dense(matcode) && mm_is_pattern(matcode)) return 0;
90			if (mm_is_real(matcode) && mm_is_hermitian(matcode)) return 0;
91			if (mm_is_pattern(matcode) && (mm_is_hermitian(matcode) \|\|
92			mm_is_skew(matcode))) return 0;
93			return 1;
94			}
95
96			int mm_read_banner(FILE f, MM_typecode matcode)
97			{
98			char line[MM_MAX_LINE_LENGTH];
99			char banner[MM_MAX_TOKEN_LENGTH];
100			char mtx[MM_MAX_TOKEN_LENGTH];
101			char crd[MM_MAX_TOKEN_LENGTH];
102			char data_type[MM_MAX_TOKEN_LENGTH];
103			char storage_scheme[MM_MAX_TOKEN_LENGTH];
104			char *p;
105
106
107			mm_clear_typecode(matcode);
108
109			if (fgets(line, MM_MAX_LINE_LENGTH, f) == NULL)
110			return MM_PREMATURE_EOF;
111
112			if (sscanf(line, "%s %s %s %s %s", banner, mtx, crd, data_type,
113			storage_scheme) != 5)
114			return MM_PREMATURE_EOF;
115
116			for (p=mtx; p!='\0'; p=tolower(p),p++); / convert to lower case */
117			for (p=crd; p!='\0'; p=tolower(*p),p++);
118			for (p=data_type; p!='\0'; p=tolower(*p),p++);
119			for (p=storage_scheme; p!='\0'; p=tolower(*p),p++);
120
121			/* check for banner */
122			if (strncmp(banner, MatrixMarketBanner, strlen(MatrixMarketBanner)) != 0)
123			return MM_NO_HEADER;
124
125			/* first field should be "mtx" */
126			if (strcmp(mtx, MM_MTX_STR) != 0)
127			return MM_UNSUPPORTED_TYPE;
128			mm_set_matrix(matcode);
129
130
131			/* second field describes whether this is a sparse matrix (in coordinate
132			storgae) or a dense array */
133
134
135			if (strcmp(crd, MM_SPARSE_STR) == 0)
136			mm_set_sparse(matcode);
137			else
138			if (strcmp(crd, MM_DENSE_STR) == 0)
139			mm_set_dense(matcode);
140			else
141			return MM_UNSUPPORTED_TYPE;
142
143
144			/* third field */
145
146			if (strcmp(data_type, MM_REAL_STR) == 0)
147			mm_set_real(matcode);
148			else
149			if (strcmp(data_type, MM_COMPLEX_STR) == 0)
150			mm_set_complex(matcode);
151			else
152			if (strcmp(data_type, MM_PATTERN_STR) == 0)
153			mm_set_pattern(matcode);
154			else
155			if (strcmp(data_type, MM_INT_STR) == 0)
156			mm_set_integer(matcode);
157			else
158			return MM_UNSUPPORTED_TYPE;
159
160
161			/* fourth field */
162
163			if (strcmp(storage_scheme, MM_GENERAL_STR) == 0)
164			mm_set_general(matcode);
165			else
166			if (strcmp(storage_scheme, MM_SYMM_STR) == 0)
167			mm_set_symmetric(matcode);
168			else
169			if (strcmp(storage_scheme, MM_HERM_STR) == 0)
170			mm_set_hermitian(matcode);
171			else
172			if (strcmp(storage_scheme, MM_SKEW_STR) == 0)
173			mm_set_skew(matcode);
174			else
175			return MM_UNSUPPORTED_TYPE;
176
177
178			return 0;
179			}
180
181			int mm_write_mtx_crd_size(FILE *f, int M, int N, int nz)
182			{
183			if (fprintf(f, "%d %d %d\n", M, N, nz) != 3)
184			return MM_COULD_NOT_WRITE_FILE;
185			else
186			return 0;
187			}
188
189			int mm_read_mtx_crd_size(FILE f, int M, int N, int nz )
190			{
191			char line[MM_MAX_LINE_LENGTH];
192			int num_items_read;
193
194			/* set return null parameter values, in case we exit with errors */
195			M = N = *nz = 0;
196
197			/* now continue scanning until you reach the end-of-comments */
198			do
199			{
200			if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL)
201			return MM_PREMATURE_EOF;
202			}while (line[0] == '%');
203
204			/* line[] is either blank or has M,N, nz */
205			if (sscanf(line, "%d %d %d", M, N, nz) == 3)
206			return 0;
207
208			else
209			do
210			{
211			num_items_read = fscanf(f, "%d %d %d", M, N, nz);
212			if (num_items_read == EOF) return MM_PREMATURE_EOF;
213			}
214			while (num_items_read != 3);
215
216			return 0;
217			}
218
219
220			int mm_read_mtx_array_size(FILE f, int M, int *N)
221			{
222			char line[MM_MAX_LINE_LENGTH];
223			int num_items_read;
224			/* set return null parameter values, in case we exit with errors */
225			M = N = 0;
226
227			/* now continue scanning until you reach the end-of-comments */
228			do
229			{
230			if (fgets(line,MM_MAX_LINE_LENGTH,f) == NULL)
231			return MM_PREMATURE_EOF;
232			}while (line[0] == '%');
233
234			/* line[] is either blank or has M,N, nz */
235			if (sscanf(line, "%d %d", M, N) == 2)
236			return 0;
237
238			else /* we have a blank line */
239			do
240			{
241			num_items_read = fscanf(f, "%d %d", M, N);
242			if (num_items_read == EOF) return MM_PREMATURE_EOF;
243			}
244			while (num_items_read != 2);
245
246			return 0;
247			}
248
249			int mm_write_mtx_array_size(FILE *f, int M, int N)
250			{
251			if (fprintf(f, "%d %d\n", M, N) != 2)
252			return MM_COULD_NOT_WRITE_FILE;
253			else
254			return 0;
255			}
256
257
258
259			/-------------------------------------------------------------------------/
260
261			/******************************************************************/
262			/* use when I[], J[], and val[]J, and val[] are already allocated */
263			/******************************************************************/
264
265			int mm_read_mtx_crd_data(FILE *f, int M, int N, int nz, int I[], int J[],
266			double val[], MM_typecode matcode)
267			{
268			int i;
269			if (mm_is_complex(matcode))
270			{
271			for (i=0; i<nz; i++)
272			if (fscanf(f, "%d %d %lg %lg", &I[i], &J[i], &val[2i], &val[2i+1])
273			!= 4) return MM_PREMATURE_EOF;
274			}
275			else if (mm_is_real(matcode))
276			{
277			for (i=0; i<nz; i++)
278			{
279			if (fscanf(f, "%d %d %lg\n", &I[i], &J[i], &val[i])
280			!= 3) return MM_PREMATURE_EOF;
281
282			}
283			}
284
285			else if (mm_is_pattern(matcode))
286			{
287			for (i=0; i<nz; i++)
288			if (fscanf(f, "%d %d", &I[i], &J[i])
289			!= 2) return MM_PREMATURE_EOF;
290			}
291			else
292			return MM_UNSUPPORTED_TYPE;
293
294			return 0;
295
296			}
297
298			int mm_read_mtx_crd_entry(FILE f, int I, int *J,
299			double real, double imag, MM_typecode matcode)
300			{
301			if (mm_is_complex(matcode))
302			{
303			if (fscanf(f, "%d %d %lg %lg", I, J, real, imag)
304			!= 4) return MM_PREMATURE_EOF;
305			}
306			else if (mm_is_real(matcode))
307			{
308			if (fscanf(f, "%d %d %lg\n", I, J, real)
309			!= 3) return MM_PREMATURE_EOF;
310
311			}
312
313			else if (mm_is_pattern(matcode))
314			{
315			if (fscanf(f, "%d %d", I, J) != 2) return MM_PREMATURE_EOF;
316			}
317			else
318			return MM_UNSUPPORTED_TYPE;
319
320			return 0;
321
322			}
323
324
325			/************************************************************************
326			mm_read_mtx_crd() fills M, N, nz, array of values, and return
327			type code, e.g. 'MCRS'
328
329			if matrix is complex, values[] is of size 2*nz,
330			(nz pairs of real/imaginary values)
331			************************************************************************/
332
333			int mm_read_mtx_crd(char fname, int M, int N, int nz, int I, int J,
334			double *val, MM_typecode matcode)
335			{
336			int ret_code;
337			FILE *f;
338
339			if (strcmp(fname, "stdin") == 0) f=stdin;
340			else
341			if ((f = fopen(fname, "r")) == NULL)
342			return MM_COULD_NOT_READ_FILE;
343
344
345			if ((ret_code = mm_read_banner(f, matcode)) != 0)
346			return ret_code;
347
348			if (!(mm_is_valid(matcode) && mm_is_sparse(matcode) &&
349			mm_is_matrix(*matcode)))
350			return MM_UNSUPPORTED_TYPE;
351
352			if ((ret_code = mm_read_mtx_crd_size(f, M, N, nz)) != 0)
353			return ret_code;
354
355
356			I = (int ) malloc(nz sizeof(int));
357			J = (int ) malloc(nz sizeof(int));
358			*val = NULL;
359
360			if (mm_is_complex(*matcode))
361			{
362			val = (double ) malloc(nz 2 * sizeof(double));
363			ret_code = mm_read_mtx_crd_data(f, M, N, nz, I, J, val,
364			*matcode);
365			if (ret_code != 0) return ret_code;
366			}
367			else if (mm_is_real(*matcode))
368			{
369			val = (double ) malloc(nz sizeof(double));
370			ret_code = mm_read_mtx_crd_data(f, M, N, nz, I, J, val,
371			*matcode);
372			if (ret_code != 0) return ret_code;
373			}
374
375			else if (mm_is_pattern(*matcode))
376			{
377			ret_code = mm_read_mtx_crd_data(f, M, N, nz, I, J, val,
378			*matcode);
379			if (ret_code != 0) return ret_code;
380			}
381
382			if (f != stdin) fclose(f);
383			return 0;
384			}
385
386			int mm_write_banner(FILE *f, MM_typecode matcode)
387			{
388			char *str = mm_typecode_to_str(matcode);
389			int ret_code;
390
391			ret_code = fprintf(f, "%s %s\n", MatrixMarketBanner, str);
392			free(str);
393			if (ret_code !=2 )
394			return MM_COULD_NOT_WRITE_FILE;
395			else
396			return 0;
397			}
398
399			int mm_write_mtx_crd(char fname[], int M, int N, int nz, int I[], int J[],
400			double val[], MM_typecode matcode)
401			{
402			FILE *f;
403			int i;
404
405			if (strcmp(fname, "stdout") == 0)
406			f = stdout;
407			else
408			if ((f = fopen(fname, "w")) == NULL)
409			return MM_COULD_NOT_WRITE_FILE;
410
411			/* print banner followed by typecode */
412			fprintf(f, "%s ", MatrixMarketBanner);
413			fprintf(f, "%s\n", mm_typecode_to_str(matcode));
414
415			/* print matrix sizes and nonzeros */
416			fprintf(f, "%d %d %d\n", M, N, nz);
417
418			/* print values */
419			if (mm_is_pattern(matcode))
420			for (i=0; i<nz; i++)
421			fprintf(f, "%d %d\n", I[i], J[i]);
422			else
423			if (mm_is_real(matcode))
424			for (i=0; i<nz; i++)
425			fprintf(f, "%d %d %20.16g\n", I[i], J[i], val[i]);
426			else
427			if (mm_is_complex(matcode))
428			for (i=0; i<nz; i++)
429			fprintf(f, "%d %d %20.16g %20.16g\n", I[i], J[i], val[2*i],
430			val[2*i+1]);
431			else
432			{
433			if (f != stdout) fclose(f);
434			return MM_UNSUPPORTED_TYPE;
435			}
436
437			if (f !=stdout) fclose(f);
438
439			return 0;
440			}
441
442
443			/**
444			* Create a new copy of a string s. strdup() is a common routine, but
445			* not part of ANSI C, so it is included here. Used by mm_typecode_to_str().
446			*
447			*/
448			char strdup(const char s)
449			{
450			int len = strlen(s);
451			char s2 = (char ) malloc((len+1)*sizeof(char));
452			return strcpy(s2, s);
453			}
454
455			char *mm_typecode_to_str(MM_typecode matcode)
456			{
457			char buffer[MM_MAX_LINE_LENGTH];
458			char *types[4];
459			char strdup(const char );
460			int error =0;
461
462			/* check for MTX type */
463			if (mm_is_matrix(matcode))
464			types[0] = MM_MTX_STR;
465			else
466			error=1;
467
468			/* check for CRD or ARR matrix */
469			if (mm_is_sparse(matcode))
470			types[1] = MM_SPARSE_STR;
471			else
472			if (mm_is_dense(matcode))
473			types[1] = MM_DENSE_STR;
474			else
475			return NULL;
476
477			/* check for element data type */
478			if (mm_is_real(matcode))
479			types[2] = MM_REAL_STR;
480			else
481			if (mm_is_complex(matcode))
482			types[2] = MM_COMPLEX_STR;
483			else
484			if (mm_is_pattern(matcode))
485			types[2] = MM_PATTERN_STR;
486			else
487			if (mm_is_integer(matcode))
488			types[2] = MM_INT_STR;
489			else
490			return NULL;
491
492
493			/* check for symmetry type */
494			if (mm_is_general(matcode))
495			types[3] = MM_GENERAL_STR;
496			else
497			if (mm_is_symmetric(matcode))
498			types[3] = MM_SYMM_STR;
499			else
500			if (mm_is_hermitian(matcode))
501			types[3] = MM_HERM_STR;
502			else
503			if (mm_is_skew(matcode))
504			types[3] = MM_SKEW_STR;
505			else
506			return NULL;
507
508			sprintf(buffer,"%s %s %s %s", types[0], types[1], types[2], types[3]);
509			return strdup(buffer);
510
511			}