246 lines
7 KiB
C
246 lines
7 KiB
C
|
|
/*! @file zreadrb.c
|
|
* \brief Read a matrix stored in Rutherford-Boeing format
|
|
*
|
|
* <pre>
|
|
* -- SuperLU routine (version 4.0) --
|
|
* Lawrence Berkeley National Laboratory.
|
|
* June 30, 2009
|
|
* </pre>
|
|
*
|
|
* Purpose
|
|
* =======
|
|
*
|
|
* Read a DOUBLE COMPLEX PRECISION matrix stored in Rutherford-Boeing format
|
|
* as described below.
|
|
*
|
|
* Line 1 (A72, A8)
|
|
* Col. 1 - 72 Title (TITLE)
|
|
* Col. 73 - 80 Matrix name / identifier (MTRXID)
|
|
*
|
|
* Line 2 (I14, 3(1X, I13))
|
|
* Col. 1 - 14 Total number of lines excluding header (TOTCRD)
|
|
* Col. 16 - 28 Number of lines for pointers (PTRCRD)
|
|
* Col. 30 - 42 Number of lines for row (or variable) indices (INDCRD)
|
|
* Col. 44 - 56 Number of lines for numerical values (VALCRD)
|
|
*
|
|
* Line 3 (A3, 11X, 4(1X, I13))
|
|
* Col. 1 - 3 Matrix type (see below) (MXTYPE)
|
|
* Col. 15 - 28 Compressed Column: Number of rows (NROW)
|
|
* Elemental: Largest integer used to index variable (MVAR)
|
|
* Col. 30 - 42 Compressed Column: Number of columns (NCOL)
|
|
* Elemental: Number of element matrices (NELT)
|
|
* Col. 44 - 56 Compressed Column: Number of entries (NNZERO)
|
|
* Elemental: Number of variable indeces (NVARIX)
|
|
* Col. 58 - 70 Compressed Column: Unused, explicitly zero
|
|
* Elemental: Number of elemental matrix entries (NELTVL)
|
|
*
|
|
* Line 4 (2A16, A20)
|
|
* Col. 1 - 16 Fortran format for pointers (PTRFMT)
|
|
* Col. 17 - 32 Fortran format for row (or variable) indices (INDFMT)
|
|
* Col. 33 - 52 Fortran format for numerical values of coefficient matrix
|
|
* (VALFMT)
|
|
* (blank in the case of matrix patterns)
|
|
*
|
|
* The three character type field on line 3 describes the matrix type.
|
|
* The following table lists the permitted values for each of the three
|
|
* characters. As an example of the type field, RSA denotes that the matrix
|
|
* is real, symmetric, and assembled.
|
|
*
|
|
* First Character:
|
|
* R Real matrix
|
|
* C Complex matrix
|
|
* I integer matrix
|
|
* P Pattern only (no numerical values supplied)
|
|
* Q Pattern only (numerical values supplied in associated auxiliary value
|
|
* file)
|
|
*
|
|
* Second Character:
|
|
* S Symmetric
|
|
* U Unsymmetric
|
|
* H Hermitian
|
|
* Z Skew symmetric
|
|
* R Rectangular
|
|
*
|
|
* Third Character:
|
|
* A Compressed column form
|
|
* E Elemental form
|
|
*
|
|
* </pre>
|
|
*/
|
|
|
|
#include "slu_zdefs.h"
|
|
|
|
|
|
/*! \brief Eat up the rest of the current line */
|
|
static int zDumpLine(FILE *fp)
|
|
{
|
|
register int c;
|
|
while ((c = fgetc(fp)) != '\n') ;
|
|
return 0;
|
|
}
|
|
|
|
static int zParseIntFormat(char *buf, int *num, int *size)
|
|
{
|
|
char *tmp;
|
|
|
|
tmp = buf;
|
|
while (*tmp++ != '(') ;
|
|
sscanf(tmp, "%d", num);
|
|
while (*tmp != 'I' && *tmp != 'i') ++tmp;
|
|
++tmp;
|
|
sscanf(tmp, "%d", size);
|
|
return 0;
|
|
}
|
|
|
|
static int zParseFloatFormat(char *buf, int *num, int *size)
|
|
{
|
|
char *tmp, *period;
|
|
|
|
tmp = buf;
|
|
while (*tmp++ != '(') ;
|
|
*num = atoi(tmp); /*sscanf(tmp, "%d", num);*/
|
|
while (*tmp != 'E' && *tmp != 'e' && *tmp != 'D' && *tmp != 'd'
|
|
&& *tmp != 'F' && *tmp != 'f') {
|
|
/* May find kP before nE/nD/nF, like (1P6F13.6). In this case the
|
|
num picked up refers to P, which should be skipped. */
|
|
if (*tmp=='p' || *tmp=='P') {
|
|
++tmp;
|
|
*num = atoi(tmp); /*sscanf(tmp, "%d", num);*/
|
|
} else {
|
|
++tmp;
|
|
}
|
|
}
|
|
++tmp;
|
|
period = tmp;
|
|
while (*period != '.' && *period != ')') ++period ;
|
|
*period = '\0';
|
|
*size = atoi(tmp); /*sscanf(tmp, "%2d", size);*/
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int ReadVector(FILE *fp, int n, int *where, int perline, int persize)
|
|
{
|
|
register int i, j, item;
|
|
char tmp, buf[100];
|
|
|
|
i = 0;
|
|
while (i < n) {
|
|
fgets(buf, 100, fp); /* read a line at a time */
|
|
for (j=0; j<perline && i<n; j++) {
|
|
tmp = buf[(j+1)*persize]; /* save the char at that place */
|
|
buf[(j+1)*persize] = 0; /* null terminate */
|
|
item = atoi(&buf[j*persize]);
|
|
buf[(j+1)*persize] = tmp; /* recover the char at that place */
|
|
where[i++] = item - 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Read complex numbers as pairs of (real, imaginary) */
|
|
static int zReadValues(FILE *fp, int n, doublecomplex *destination, int perline, int persize)
|
|
{
|
|
register int i, j, k, s, pair;
|
|
register double realpart;
|
|
char tmp, buf[100];
|
|
|
|
i = pair = 0;
|
|
while (i < n) {
|
|
fgets(buf, 100, fp); /* read a line at a time */
|
|
for (j=0; j<perline && i<n; j++) {
|
|
tmp = buf[(j+1)*persize]; /* save the char at that place */
|
|
buf[(j+1)*persize] = 0; /* null terminate */
|
|
s = j*persize;
|
|
for (k = 0; k < persize; ++k) /* No D_ format in C */
|
|
if ( buf[s+k] == 'D' || buf[s+k] == 'd' ) buf[s+k] = 'E';
|
|
if ( pair == 0 ) {
|
|
/* The value is real part */
|
|
realpart = atof(&buf[s]);
|
|
pair = 1;
|
|
} else {
|
|
/* The value is imaginary part */
|
|
destination[i].r = realpart;
|
|
destination[i++].i = atof(&buf[s]);
|
|
pair = 0;
|
|
}
|
|
buf[(j+1)*persize] = tmp; /* recover the char at that place */
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void
|
|
zreadrb(int *nrow, int *ncol, int *nonz,
|
|
doublecomplex **nzval, int **rowind, int **colptr)
|
|
{
|
|
|
|
register int i, numer_lines = 0;
|
|
int tmp, colnum, colsize, rownum, rowsize, valnum, valsize;
|
|
char buf[100], type[4];
|
|
FILE *fp;
|
|
|
|
fp = stdin;
|
|
|
|
/* Line 1 */
|
|
fgets(buf, 100, fp);
|
|
fputs(buf, stdout);
|
|
|
|
/* Line 2 */
|
|
for (i=0; i<4; i++) {
|
|
fscanf(fp, "%14c", buf); buf[14] = 0;
|
|
sscanf(buf, "%d", &tmp);
|
|
if (i == 3) numer_lines = tmp;
|
|
}
|
|
zDumpLine(fp);
|
|
|
|
/* Line 3 */
|
|
fscanf(fp, "%3c", type);
|
|
fscanf(fp, "%11c", buf); /* pad */
|
|
type[3] = 0;
|
|
#ifdef DEBUG
|
|
printf("Matrix type %s\n", type);
|
|
#endif
|
|
|
|
fscanf(fp, "%14c", buf); sscanf(buf, "%d", nrow);
|
|
fscanf(fp, "%14c", buf); sscanf(buf, "%d", ncol);
|
|
fscanf(fp, "%14c", buf); sscanf(buf, "%d", nonz);
|
|
fscanf(fp, "%14c", buf); sscanf(buf, "%d", &tmp);
|
|
|
|
if (tmp != 0)
|
|
printf("This is not an assembled matrix!\n");
|
|
if (*nrow != *ncol)
|
|
printf("Matrix is not square.\n");
|
|
zDumpLine(fp);
|
|
|
|
/* Allocate storage for the three arrays ( nzval, rowind, colptr ) */
|
|
zallocateA(*ncol, *nonz, nzval, rowind, colptr);
|
|
|
|
/* Line 4: format statement */
|
|
fscanf(fp, "%16c", buf);
|
|
zParseIntFormat(buf, &colnum, &colsize);
|
|
fscanf(fp, "%16c", buf);
|
|
zParseIntFormat(buf, &rownum, &rowsize);
|
|
fscanf(fp, "%20c", buf);
|
|
zParseFloatFormat(buf, &valnum, &valsize);
|
|
zDumpLine(fp);
|
|
|
|
#ifdef DEBUG
|
|
printf("%d rows, %d nonzeros\n", *nrow, *nonz);
|
|
printf("colnum %d, colsize %d\n", colnum, colsize);
|
|
printf("rownum %d, rowsize %d\n", rownum, rowsize);
|
|
printf("valnum %d, valsize %d\n", valnum, valsize);
|
|
#endif
|
|
|
|
ReadVector(fp, *ncol+1, *colptr, colnum, colsize);
|
|
ReadVector(fp, *nonz, *rowind, rownum, rowsize);
|
|
if ( numer_lines ) {
|
|
zReadValues(fp, *nonz, *nzval, valnum, valsize);
|
|
}
|
|
|
|
fclose(fp);
|
|
}
|