void extra_matio_print_all_var_info (mat_t * matfp, int printdata) {
matvar_t *matvar;
fflush(stdout);
if (printdata)
while ( NULL != (matvar = Mat_VarReadNext(matfp)) ) {
Mat_VarPrint(matvar,printdata);
Mat_VarFree(matvar);
}
else
while ( NULL != (matvar = Mat_VarReadNextInfo(matfp)) ) {
Mat_VarPrint(matvar,printdata);
Mat_VarFree(matvar);
}
fflush(stdout);
}
void extra_matio_print_all_var_info_clumsy(mat_t * matfp) {
matvar_t *matvar;
size_t nbytes;
int i;
char size[32] = {' ',};
fflush(stdout);
printf( "%-20s %-10s %-10s %-18s\n", "Name", "Size", "Bytes", "Class");
while ( NULL != (matvar = Mat_VarReadNextInfo(matfp)) ) {
printf("%-20s", matvar->name);
if ( matvar->rank > 0 ) {
int cnt = 0;
printf("%8d", matvar->dims[0]);
for ( i = 1; i < matvar->rank; i++ ) {
if ( ceil(log10(matvar->dims[i]))+1 < 32 )
cnt += sprintf(size+cnt,"x%d", matvar->dims[i]);
}
printf("%-10s",size);
} else {
printf(" ");
}
nbytes = Mat_VarGetSize(matvar);
printf(" %8d",nbytes);
printf(" %-18s\n",mxclass[matvar->class_type-1]);
Mat_VarPrint(matvar,0);
Mat_VarFree(matvar);
}
fflush(stdout);
}
static void
print_default(matvar_t *matvar)
{
if ( NULL == matvar )
return;
switch ( matvar->class_type ) {
case MAT_C_DOUBLE:
case MAT_C_SINGLE:
case MAT_C_INT64:
case MAT_C_UINT64:
case MAT_C_INT32:
case MAT_C_UINT32:
case MAT_C_INT16:
case MAT_C_UINT16:
case MAT_C_INT8:
case MAT_C_UINT8:
{
if ( matvar->rank == 2 )
print_default_numeric_2d(matvar);
else if ( matvar->rank == 3 )
print_default_numeric_3d(matvar);
break;
}
case MAT_C_CHAR:
case MAT_C_SPARSE:
Mat_VarPrint(matvar, printdata);
break;
case MAT_C_STRUCT:
{
matvar_t **fields = (matvar_t **)matvar->data;
int nfields;
int i;
size_t nmemb;
if ( matvar->name )
Mat_Message(" Name: %s", matvar->name);
Mat_Message(" Rank: %d", matvar->rank);
if ( matvar->rank == 0 )
return;
Mat_Message("Class Type: Structure");
nfields = Mat_VarGetNumberOfFields(matvar);
nmemb = matvar->dims[0];
for ( i = 1; i < matvar->rank; i++ )
nmemb *= matvar->dims[i];
if ( nfields > 0 && nmemb < 1 ) {
char * const *fieldnames = Mat_VarGetStructFieldnames(matvar);
Mat_Message("Fields[%d] {", nfields);
indent++;
for ( i = 0; i < nfields; i++ )
Mat_Message(" Name: %s", fieldnames[i]);
indent--;
Mat_Message("}");
} else if ( nfields > 0 && nmemb > 0 ) {
Mat_Message("Fields[%d] {", nfields);
indent++;
for ( i = 0; i < nfields*nmemb; i++ )
print_default(fields[i]);
indent--;
Mat_Message("}");
}
break;
}
case MAT_C_CELL:
{
matvar_t **cells = (matvar_t **)matvar->data;
size_t ncells;
int i;
if ( matvar->name )
Mat_Message(" Name: %s", matvar->name);
Mat_Message(" Rank: %d", matvar->rank);
if ( matvar->rank == 0 )
return;
ncells = matvar->dims[0];
for ( i = 1; i < matvar->rank; i++ )
ncells *= matvar->dims[i];
Mat_Message("Class Type: Cell Array");
Mat_Message("{");
indent++;
for ( i = 0; i < ncells; i++ )
print_default(cells[i]);
indent--;
Mat_Message("}");
break;
}
default:
Mat_Message("Empty");
}
}
// load a .mat matlab matrix
// will load the first matrix (sparse or dense) in the file
// returns 0 on success
static
int read_mat(char const *const filename,
matrix_t *const A) {
#ifndef HAVE_MATIO
return 1;
#else
const int LOCAL_DEBUG = 0;
mat_t* matfp;
matfp = Mat_Open(filename, MAT_ACC_RDONLY);
if(matfp == NULL)
return 1; // failed to open file
matvar_t* t;
int more_data = 1;
while (more_data) {
t = Mat_VarReadNextInfo(matfp);
if(t == NULL) {
return 2; // no suitable variable found
}
// TODO decide if this is the one: if(t->
if(1) {
more_data = 0;
}
else { // keep going
Mat_VarFree(t);
t = NULL;
}
}
{ // load the selected variable, including data
Mat_Rewind(matfp);
matvar_t* tt = Mat_VarRead(matfp, t->name);
Mat_VarFree(t);
t = tt;
if(LOCAL_DEBUG) Mat_VarPrint(tt, 1);
}
// debug info
if(LOCAL_DEBUG && t->name != NULL)
printf("%s: loaded variable %s\n", filename, t->name);
// checks and data handling
int ret = 0;
if(t->rank > 2 || t->rank <= 0) { // number of dimensions
ret = 2;
}
else if(t->data_type != MAT_T_DOUBLE) {
if(LOCAL_DEBUG) printf("data_type=%d\n",t->data_type);
ret = 3;
}
else if(t->isComplex) {
ret = 10; // TODO can't handle complex matrices yet
}
else if(t->isLogical) {
ret = 11; // TODO can't handle logicals yet
}
else {
if(t->rank == 1) {
A->m = t->dims[0]; // rows
A->n = 1; // cols
}
else {
A->m = t->dims[0]; // rows
A->n = t->dims[1]; // cols
}
A->sym = SM_UNSYMMETRIC;
//if(t->data_type == MAT_T_DOUBLE) {
A->data_type = REAL_DOUBLE;
//} // TODO complex, single precision, various sized integers
if(t->class_type == MAT_C_SPARSE) { // t.data = sparse_t in CSC format
// Note that Matlab will save('-v4'...) a sparse matrix
// to version 4 format without complaint but it appears
// to be gibberish as far as MatIO is concerned
sparse_t* st = t->data;
A->nz = st->ndata; //st->nzmax has the actual size of the allocated st->data
A->format = SM_CSC;
// transfer the data pointer into our strucut
// TODO check for negative values in ir/jc before throwing away their signs
A->ii = (unsigned int*) st->ir;
st->ir = NULL;
A->jj = (unsigned int*) st->jc;
st->jc = NULL;
A->dd = st->data;
st->data = NULL;
}
else if(t->class_type == MAT_C_DOUBLE) {
A->nz = A->m * A->n;
A->format = DCOL;
// transfer the data pointer into our struct
A->dd = t->data;
t->data = NULL;
}
else {
ret = 4; // unknown class of data structure
}
}
// DEBUG
if(LOCAL_DEBUG && validate_matrix(A) != 0) {
ret = 50;
fprintf(stderr, "problem loading .mat matrix file\n");
printf_matrix(" ", A);
}
// sanity checks
// t.dims[] is don't-care
// t.isGlobal is don't-care
Mat_Close(matfp);
Mat_VarFree(t);
return ret; // success?
#endif
}
