Example #1
0
/*
   -----------------------------------
   this method initializes a A2 object 
   to point into the entries

   created -- 98may02, cca
   -----------------------------------
*/
void
DenseMtx_setA2 (
   DenseMtx   *mtx,
   A2         *a2
) {
/*
   ---------------
   check the input
   ---------------
*/
if (  mtx == NULL || a2 == NULL ) {
   fprintf(stderr, "\n fatal error in DenseMtx_setZA2(%p,%p)"
           "\n bad input\n", mtx, a2) ;
   exit(-1) ;
}
/*
if ( DENSEMTX_IS_REAL(mtx) ) {
   A2_init(a2, SPOOLES_REAL, mtx->nrow, mtx->ncol, mtx->inc1, mtx->inc2,
           mtx->entries) ;
} else if ( DENSEMTX_IS_COMPLEX(mtx) ) {
   A2_init(a2, SPOOLES_COMPLEX, mtx->nrow, mtx->ncol, mtx->inc1, mtx->inc2,
           mtx->entries) ;
}
*/
A2_init(a2, mtx->type, mtx->nrow, mtx->ncol, 
        mtx->inc1, mtx->inc2, mtx->entries) ;
return ; }
Example #2
0
/*--------------------------------------------------------------------*/
int
main ( int argc, char *argv[] )
/*
   -----------------------
   simple test program

   created -- 98apr15, cca
   -----------------------
*/
{
A2       *A ;
double   t1, t2, value ;
FILE     *msgFile ;
int      inc1, inc2, irow, jcol,
         msglvl, nrow, ncol, seed, type ;

if ( argc != 9 ) {
   fprintf(stdout, 
"\n\n usage : %s msglvl msgFile type nrow ncol inc1 inc2 seed "
"\n    msglvl  -- message level"
"\n    msgFile -- message file"
"\n    type    -- entries type"
"\n      1 -- real"
"\n      2 -- complex"
"\n    nrow    -- # of rows "
"\n    ncol    -- # of columns "
"\n    inc1    -- row increment "
"\n    inc2    -- column increment "
"\n    seed    -- random number seed"
"\n", argv[0]) ;
   return(0) ;
}
if ( (msglvl = atoi(argv[1])) < 0 ) {
   fprintf(stderr, "\n message level must be positive\n") ;
   spoolesFatal();
}
if ( strcmp(argv[2], "stdout") == 0 ) {
   msgFile = stdout ;
} else if ( (msgFile = fopen(argv[2], "a")) == NULL ) {
   fprintf(stderr, "\n unable to open file %s\n", argv[2]) ;
   return(-1) ;
}
type = atoi(argv[3]) ;
nrow = atoi(argv[4]) ;
ncol = atoi(argv[5]) ;
inc1 = atoi(argv[6]) ;
inc2 = atoi(argv[7]) ;
if (   type < 1 || type > 2 || nrow < 0 || ncol < 0 
    || inc1 < 1 || inc2 < 1 ) {
   fprintf(stderr, 
       "\n fatal error, type %d, nrow %d, ncol %d, inc1 %d, inc2 %d",
       type, nrow, ncol, inc1, inc2) ;
   spoolesFatal();
}
seed = atoi(argv[7]) ;
fprintf(msgFile, "\n\n %% %s :"
        "\n %% msglvl  = %d"
        "\n %% msgFile = %s"
        "\n %% type    = %d"
        "\n %% nrow    = %d"
        "\n %% ncol    = %d"
        "\n %% inc1    = %d"
        "\n %% inc2    = %d"
        "\n %% seed    = %d"
        "\n",
        argv[0], msglvl, argv[2], type, nrow, ncol, inc1, inc2, seed) ;
/*
   -----------------------------
   initialize the matrix objects
   -----------------------------
*/
MARKTIME(t1) ;
A = A2_new() ;
A2_init(A, type, nrow, ncol, inc1, inc2, NULL) ;
MARKTIME(t2) ;
fprintf(msgFile, "\n %% CPU : %.3f to initialize matrix object",
        t2 - t1) ;
MARKTIME(t1) ;
A2_fillRandomUniform(A, -1, 1, seed) ;
seed++ ;
MARKTIME(t2) ;
fprintf(msgFile, 
      "\n %% CPU : %.3f to fill matrix with random numbers", t2 - t1) ;
if ( msglvl > 3 ) {
   fprintf(msgFile, "\n matrix A") ;
   A2_writeForHumanEye(A, msgFile) ;
}
if ( msglvl > 1 ) {
   fprintf(msgFile, "\n %% matrix A") ;
   A2_writeForMatlab(A, "A", msgFile) ;
}
/*
   -------------
   get the norms
   -------------
*/
value = A2_maxabs(A) ;
fprintf(msgFile, "\n error_maxabs = abs(%20.12e - max(max(abs(A))))",
        value) ;
value = A2_frobNorm(A) ;
fprintf(msgFile, "\n error_frob = abs(%20.12e - norm(A, 'fro'))",
        value) ;
value  = A2_oneNorm(A) ;
fprintf(msgFile, "\n error_one = abs(%20.12e - norm(A, 1))",
        value) ;
value  = A2_infinityNorm(A) ;
fprintf(msgFile, "\n error_inf = abs(%20.12e - norm(A, inf))",
        value) ;
for ( irow = 0 ; irow < nrow ; irow++ ) {
   value = A2_infinityNormOfRow(A, irow) ;
   fprintf(msgFile, 
    "\n error_infNormsOfRows(%d) = abs(%20.12e - norm(A(%d,:), inf)) ;",
    irow+1, value, irow+1) ;
   value = A2_oneNormOfRow(A, irow) ;
   fprintf(msgFile, 
    "\n error_oneNormsOfRows(%d) = abs(%20.12e - norm(A(%d,:), 1)) ;",
    irow+1, value, irow+1) ;
   value = A2_twoNormOfRow(A, irow) ;
   fprintf(msgFile, 
    "\n error_twoNormsOfRows(%d) = abs(%20.12e - norm(A(%d,:), 2)) ;",
    irow+1, value, irow+1) ;
}
for ( jcol = 0 ; jcol < ncol ; jcol++ ) {
   value = A2_infinityNormOfColumn(A, jcol) ;
   fprintf(msgFile, 
 "\n error_infNormsOfColumns(%d) = abs(%20.12e - norm(A(:,%d), inf)) ;",
    jcol+1, value, jcol+1) ;
   value = A2_oneNormOfColumn(A, jcol) ;
   fprintf(msgFile, 
   "\n error_oneNormsOfColumns(%d) = abs(%20.12e - norm(A(:,%d), 1)) ;",
      jcol+1, value, jcol+1) ;
   value = A2_twoNormOfColumn(A, jcol) ;
   fprintf(msgFile, 
   "\n error_twoNormsOfColumns(%d) = abs(%20.12e - norm(A(:,%d), 2)) ;",
      jcol+1, value, jcol+1) ;
}
fprintf(msgFile, 
"\n error_in_row_norms = [ max(error_infNormsOfRows) "
"\n                        max(error_oneNormsOfRows) "
"\n                        max(error_twoNormsOfRows) ]"
"\n error_in_column_norms = [ max(error_infNormsOfColumns) "
"\n                           max(error_oneNormsOfColumns) "
"\n                           max(error_twoNormsOfColumns) ]") ;
fprintf(msgFile, "\n") ;
/*
   ------------------------
   free the working storage
   ------------------------
*/
A2_free(A) ;

return(0) ; }
Example #3
0
/*
   --------------------------------------------------
   purpose -- to read an object from a formatted file

   return value -- 1 if success, 0 if failure

   created -- 98may01, cca
   --------------------------------------------------
*/
int
A2_readFromFormattedFile ( 
   A2    *mtx, 
   FILE   *fp 
) {
int   rc, size ;
int   itemp[5] ;
/*
   ---------------
   check the input
   ---------------
*/
if ( mtx == NULL || fp == NULL ) {
   fprintf(stderr, "\n error in A2_readFromFormattedFile(%p,%p)"
           "\n bad input", mtx, fp) ;
   return(0) ;
}
/*
   ---------------------
   clear the data fields
   ---------------------
*/
A2_clearData(mtx) ;
/*
   -----------------------------------------------------------
   read in the five scalar parameters: type n1, n2, inc1, inc2
   -----------------------------------------------------------
*/
if ( (rc = IVfscanf(fp, 5, itemp)) != 5 ) {
   fprintf(stderr, "\n error in A2_readFromFormattedFile()"
           "\n %d items of %d read\n", rc, 5) ;
   return(0) ;
}
/*
   ---------------------
   initialize the object
   ---------------------
*/
A2_init(mtx, itemp[0], itemp[1], itemp[2], itemp[3], itemp[4], NULL) ;
/*
   ----------------------------
   read in the entries[] vector
   ----------------------------
*/
if ( (size = 1 + (mtx->n1-1)*mtx->inc1 + (mtx->n2-1)*mtx->inc2) > 0 ) {
   if ( A2_IS_REAL(mtx) ) {
      if ( (rc = DVfscanf(fp, size, mtx->entries)) != size ) {
         fprintf(stderr, "\n error in A2_readFromFormattedFile"
                 "\n %d items of %d read\n", rc, size) ;
         return(0) ;
      }
   } else if ( A2_IS_COMPLEX(mtx) ) {
      if ( (rc = DVfscanf(fp, 2*size, mtx->entries)) != 2*size ) {
         fprintf(stderr, "\n error in A2_readFromFormattedFile"
                 "\n %d items of %d read\n", rc, 2*size) ;
         return(0) ;
      }
   }
}

return(1) ; }
Example #4
0
/*
   --------------------------------------------------------------
   purpose -- create and return an A2 object that contains rows
              of A and rows from update matrices of the children.
              the matrix may not be in staircase form

   created -- 98may25, cca
   --------------------------------------------------------------
*/
A2 *
FrontMtx_QR_assembleFront (
   FrontMtx   *frontmtx,
   int        J,
   InpMtx     *mtxA,
   IVL        *rowsIVL,
   int        firstnz[],
   int        colmap[],
   Chv        *firstchild,
   DV         *workDV,
   int        msglvl,
   FILE       *msgFile
) {
A2       *frontJ ;
Chv      *chvI ;
double   *rowI, *rowJ, *rowentA ;
int      ii, irow, irowA, irowI, jcol, jj, jrow, ncolI, ncolJ, 
         nentA, nrowI, nrowJ, nrowFromA ;
int      *colindA, *colindI, *colindJ, *map, *rowids, *rowsFromA ;
/*
   ---------------
   check the input
   ---------------
*/
if ( frontmtx == NULL || mtxA == NULL || rowsIVL == NULL
   || (msglvl > 0 && msgFile == NULL) ) {
   fprintf(stderr, "\n fatal error in FrontMtx_QR_assembleFront()"
           "\n bad input\n") ;
   exit(-1) ;
}
if ( msglvl > 3 ) {
   fprintf(msgFile, "\n\n inside FrontMtx_QR_assembleFront(%d)", J) ;
   fflush(msgFile) ;
}
/*
   --------------------------------------------------
   set up the map from global to local column indices
   --------------------------------------------------
*/
FrontMtx_columnIndices(frontmtx, J, &ncolJ, &colindJ) ;
for ( jcol = 0 ; jcol < ncolJ ; jcol++ ) {
   colmap[colindJ[jcol]] = jcol ;
}
if ( msglvl > 3 ) {
   fprintf(msgFile, "\n front %d's column indices", J) ;
   IVfprintf(msgFile, ncolJ, colindJ) ;
   fflush(msgFile) ;
}
/*
   -------------------------------------------------
   compute the size of the front and map the global 
   indices of the update matrices into local indices
   -------------------------------------------------
*/
IVL_listAndSize(rowsIVL, J, &nrowFromA, &rowsFromA) ;
nrowJ = nrowFromA ;
if ( msglvl > 3 ) {
   fprintf(msgFile, "\n %d rows from A", nrowFromA) ;
   fflush(msgFile) ;
}
for ( chvI = firstchild ; chvI != NULL ; chvI = chvI->next ) {
   nrowJ += chvI->nD ;
   Chv_columnIndices(chvI, &ncolI, &colindI) ;
   for ( jcol = 0 ; jcol < ncolI ; jcol++ ) {
      colindI[jcol] = colmap[colindI[jcol]] ;
   }
   if ( msglvl > 3 ) {
      fprintf(msgFile, "\n %d rows from child %d", chvI->nD, chvI->id) ;
      fflush(msgFile) ;
   }
}
/*
   ----------------------------------------------------------
   get workspace for the rowids[nrowJ] and map[nrowJ] vectors
   ----------------------------------------------------------
*/
if ( sizeof(int) == sizeof(double) ) {
   DV_setSize(workDV, 2*nrowJ) ;
} else if ( 2*sizeof(int) == sizeof(double) ) {
   DV_setSize(workDV, nrowJ) ;
}
rowids = (int *) DV_entries(workDV) ;
map    = rowids + nrowJ ;
IVramp(nrowJ, rowids, 0, 1) ;
IVfill(nrowJ, map, -1) ;
/*
   -----------------------------------------------------------------
   get the map from incoming rows to their place in the front matrix
   -----------------------------------------------------------------
*/
for ( irow = jrow = 0 ; irow < nrowFromA ; irow++, jrow++ ) {
   irowA = rowsFromA[irow] ;
   map[jrow] = colmap[firstnz[irowA]] ;
}
for ( chvI = firstchild ; chvI != NULL ; chvI = chvI->next ) {
   nrowI = chvI->nD ;
   Chv_columnIndices(chvI, &ncolI, &colindI) ;
   for ( irow = 0 ; irow < nrowI ; irow++, jrow++ ) {
      map[jrow] = colindI[irow] ;
   }
}
IV2qsortUp(nrowJ, map, rowids) ;
for ( irow = 0 ; irow < nrowJ ; irow++ ) {
   map[rowids[irow]] = irow ;
}
/*
   ----------------------------
   allocate the A2 front object
   ----------------------------
*/
frontJ = A2_new() ;
A2_init(frontJ, frontmtx->type, nrowJ, ncolJ, ncolJ, 1, NULL) ;
A2_zero(frontJ) ;
/*
   ------------------------------------
   load the original rows of the matrix
   ------------------------------------
*/
for ( jrow = 0 ; jrow < nrowFromA ; jrow++ ) {
   irowA = rowsFromA[jrow] ;
   rowJ  = A2_row(frontJ, map[jrow]) ;
   if ( A2_IS_REAL(frontJ) ) {
      InpMtx_realVector(mtxA, irowA, &nentA, &colindA, &rowentA) ;
   } else if ( A2_IS_COMPLEX(frontJ) ) {
      InpMtx_complexVector(mtxA, irowA, &nentA, &colindA, &rowentA) ;
   }
   if ( msglvl > 3 ) {
      fprintf(msgFile, "\n loading row %d", irowA) ;
      fprintf(msgFile, "\n global indices") ;
      IVfprintf(msgFile, nentA, colindA) ;
      fflush(msgFile) ;
   }
   if ( A2_IS_REAL(frontJ) ) {
      for ( ii = 0 ; ii < nentA ; ii++ ) {
         jj = colmap[colindA[ii]] ;
         rowJ[jj] = rowentA[ii] ;
      }
   } else if ( A2_IS_COMPLEX(frontJ) ) {
      for ( ii = 0 ; ii < nentA ; ii++ ) {
         jj = colmap[colindA[ii]] ;
         rowJ[2*jj]   = rowentA[2*ii]   ;
         rowJ[2*jj+1] = rowentA[2*ii+1] ;
      }
   }
}
if ( msglvl > 3 ) {
   fprintf(msgFile, "\n after assembling rows of A") ;
   A2_writeForHumanEye(frontJ, msgFile) ;
   fflush(msgFile) ;
}
/*
   ----------------------------------
   load the updates from the children 
   ----------------------------------
*/
for ( chvI = firstchild ; chvI != NULL ; chvI = chvI->next ) {
   nrowI = chvI->nD ;
   Chv_columnIndices(chvI, &ncolI, &colindI) ;
   if ( msglvl > 3 ) {
      fprintf(msgFile, "\n loading child %d", chvI->id) ;
      fprintf(msgFile, "\n child's column indices") ;
      IVfprintf(msgFile, ncolI, colindI) ;
      Chv_writeForHumanEye(chvI, msgFile) ;
      fflush(msgFile) ;
   }
   rowI = Chv_entries(chvI) ;
   for ( irowI = 0 ; irowI < nrowI ; irowI++, jrow++ ) {
      rowJ = A2_row(frontJ, map[jrow]) ;
      if ( A2_IS_REAL(frontJ) ) {
         for ( ii = irowI ; ii < ncolI ; ii++ ) {
            jj = colindI[ii] ;
            rowJ[jj] = rowI[ii] ;
         }
         rowI += ncolI - irowI - 1 ;
      } else if ( A2_IS_COMPLEX(frontJ) ) {
         for ( ii = irowI ; ii < ncolI ; ii++ ) {
            jj = colindI[ii] ;
            rowJ[2*jj]   = rowI[2*ii]   ;
            rowJ[2*jj+1] = rowI[2*ii+1] ;
         }
         rowI += 2*(ncolI - irowI - 1) ;
      }
   }
   if ( msglvl > 3 ) {
      fprintf(msgFile, "\n after assembling child %d", chvI->id) ;
      A2_writeForHumanEye(frontJ, msgFile) ;
      fflush(msgFile) ;
   }
}
return(frontJ) ; }
Example #5
0
/*
   -----------------------------------------------
   purpose -- to read an object from a binary file

   return value -- 1 if success, 0  if failure

   created -- 98may01, cca
   -----------------------------------------------
*/
int
A2_readFromBinaryFile ( 
   A2    *mtx, 
   FILE   *fp 
) {
int   rc, size ;
int   itemp[5] ;
/*
   ---------------
   check the input
   ---------------
*/
if ( mtx == NULL || fp == NULL ) {
   fprintf(stderr, "\n fatal error in A2_readFromBinaryFile(%p,%p)"
           "\n bad input", mtx, fp) ;
   return(0) ;
}
/*
   ---------------------
   clear the data fields
   ---------------------
*/
A2_clearData(mtx) ;
/*
   ------------------------------------------------------------
   read in the five scalar parameters: type, n1, n2, inc1, inc2
   ------------------------------------------------------------
*/
if ( (rc = fread((char *) itemp, sizeof(int), 5, fp)) != 5 ) {
   fprintf(stderr, "\n error in A2_readFromBinaryFile"
           "\n %d items of %d read\n", rc, 5) ;
   return(0) ;
}
fprintf(stdout, "\n itemp = {%d, %d, %d, %d, %d}", 
        itemp[0], itemp[1], itemp[2], itemp[3], itemp[4]) ;
fflush(stdout) ;
/*
   ---------------------
   initialize the object
   ---------------------
*/
A2_init(mtx, itemp[0], itemp[1], itemp[2], itemp[3], itemp[4], NULL) ;
/*
   ----------------------------
   read in the entries[] vector
   ----------------------------
*/
if ( (size = 1 + (mtx->n1-1)*mtx->inc1 + (mtx->n2-1)*mtx->inc2) > 0 ) {
   if ( A2_IS_REAL(mtx) ) {
      if ( (rc = fread(mtx->entries, sizeof(double), size, fp)) 
           != size ) {
         fprintf(stderr, "\n error in A2_readFromBinaryFile"
                 "\n %d items of %d read\n", rc, size) ;
         return(0) ;
      }
   } else if ( A2_IS_COMPLEX(mtx) ) {
      if ( (rc = fread(mtx->entries, sizeof(double), 2*size, fp)) 
           != 2*size ) {
         fprintf(stderr, "\n error in A2_readFromBinaryFile"
                 "\n %d items of %d read\n", rc, 2*size) ;
         return(0) ;
      }
   }
}

return(1) ; }