/* ========================================================================== */
  /* === UMFPACK_report_info ================================================== */
  /* ========================================================================== */
  
  /* -------------------------------------------------------------------------- */
  /* UMFPACK Copyright (c) Timothy A. Davis, CISE,                              */
  /* Univ. of Florida.  All Rights Reserved.  See ../Doc/License for License.   */
  /* web: http://www.cise.ufl.edu/research/sparse/umfpack                       */
  /* -------------------------------------------------------------------------- */
  
  /*
      User-callable.  Prints the Info array.  See umfpack_report_info.h for
      details.
  */
  
  #include "umf_internal.h"
  
  #define PRINT_INFO(format,x) \
  { \
      if (SCALAR_IS_NAN (x) || (!SCALAR_IS_LTZERO (x))) \
      { \
  	PRINTF ((format, x)) ; \
      } \
  }
  
  /* RATIO macro uses a double relop, but ignore NaN case: */
  #define RATIO(a,b,c) (((b) == 0) ? (c) : (((double) a)/((double) b)))
  
  /* ========================================================================== */
  /* === print_ratio ========================================================== */
  /* ========================================================================== */
  
  PRIVATE void print_ratio
  (
      char *what,
      char *format,
      double estimate,
      double actual
  )
  {
      if (estimate < 0 && actual < 0)	/* double relop, but ignore Nan case */
      {
  	return ;
      }
      PRINTF (("    %-27s", what)) ;
      if (estimate >= 0)			/* double relop, but ignore Nan case */
      {
  	PRINTF ((format, estimate)) ;
      }
      else
      {
  	PRINTF (("                    -")) ;
      }
      if (actual >= 0)			/* double relop, but ignore Nan case */
      {
  	PRINTF ((format, actual)) ;
      }
      else
      {
  	PRINTF (("                    -")) ;
      }
      if (estimate >= 0 && actual >= 0)	/* double relop, but ignore Nan case */
      {
  	PRINTF ((" %5.0f%%
  ", 100 * RATIO (actual, estimate, 1))) ;
      }
      else
      {
  	PRINTF (("      -
  ")) ;
      }
  }
  
  /* ========================================================================== */
  /* === UMFPACK_report_info ================================================== */
  /* ========================================================================== */
  
  GLOBAL void UMFPACK_report_info
  (
      const double Control [UMFPACK_CONTROL],
      const double Info [UMFPACK_INFO]
  )
  {
  
      double lnz_est, unz_est, lunz_est, lnz, unz, lunz, tsym, tnum, fnum, tsolve,
  	fsolve, ttot, ftot, twsym, twnum, twsolve, twtot, n2 ;
      Int n_row, n_col, n_inner, prl, is_sym ;
  
      /* ---------------------------------------------------------------------- */
      /* get control settings and status to determine what to print */
      /* ---------------------------------------------------------------------- */
  
      prl = GET_CONTROL (UMFPACK_PRL, UMFPACK_DEFAULT_PRL) ;
  
      if (!Info || prl < 2)
      {
  	/* no output generated if Info is (double *) NULL */
  	/* or if prl is less than 2 */
  	return ;
      }
  
      /* ---------------------------------------------------------------------- */
      /* print umfpack version */
      /* ---------------------------------------------------------------------- */
  
      PRINTF  (("UMFPACK V%d.%d.%d (%s), Info:
  ", UMFPACK_MAIN_VERSION,
  	UMFPACK_SUB_VERSION, UMFPACK_SUBSUB_VERSION, UMFPACK_DATE)) ;
  
  #ifndef NDEBUG
      PRINTF ((
  "**** Debugging enabled (UMFPACK will be exceedingly slow!) *****************
  "
      )) ;
  #endif
  
      /* ---------------------------------------------------------------------- */
      /* print run-time options */
      /* ---------------------------------------------------------------------- */
  
  #ifdef DINT
      PRINTF (("    matrix entry defined as:          double
  ")) ;
      PRINTF (("    Int (generic integer) defined as: int
  ")) ;
  #endif
  #ifdef DLONG
      PRINTF (("    matrix entry defined as:          double
  ")) ;
      PRINTF (("    Int (generic integer) defined as: UF_long
  ")) ;
  #endif
  #ifdef ZINT
      PRINTF (("    matrix entry defined as:          double complex
  ")) ;
      PRINTF (("    Int (generic integer) defined as: int
  ")) ;
  #endif
  #ifdef ZLONG
      PRINTF (("    matrix entry defined as:          double complex
  ")) ;
      PRINTF (("    Int (generic integer) defined as: UF_long
  ")) ;
  #endif
  
      /* ---------------------------------------------------------------------- */
      /* print compile-time options */
      /* ---------------------------------------------------------------------- */
  
      PRINTF (("    BLAS library used: ")) ;
  
  #ifdef NBLAS
      PRINTF (("none.  UMFPACK will be slow.
  ")) ;
  #else
      PRINTF (("Fortran BLAS.  size of BLAS integer: "ID"
  ",
  	(Int) (sizeof (BLAS_INT)))) ;
  #endif
  
      PRINTF (("    MATLAB:                           ")) ;
  #ifdef MATLAB_MEX_FILE
      PRINTF (("yes.
  ")) ;
  #else
  #ifdef MATHWORKS
      PRINTF (("yes.
  ")) ;
  #else
      PRINTF (("no.
  ")) ;
  #endif
  #endif
  
      PRINTF (("    CPU timer:                        ")) ;
  #ifdef NO_TIMER
      PRINTF (("none.
  ")) ;
  #else
  #ifndef NPOSIX
      PRINTF (("POSIX times ( ) routine.
  ")) ;
  #else
  #ifdef GETRUSAGE
      PRINTF (("getrusage ( ) routine.
  ")) ;
  #else
      PRINTF (("ANSI clock ( ) routine.
  ")) ;
  #endif
  #endif
  #endif
  
      /* ---------------------------------------------------------------------- */
      /* print n and nz */
      /* ---------------------------------------------------------------------- */
  
      n_row = (Int) Info [UMFPACK_NROW] ;
      n_col = (Int) Info [UMFPACK_NCOL] ;
      n_inner = MIN (n_row, n_col) ;
  
      PRINT_INFO ("    number of rows in matrix A:       "ID"
  ", n_row) ;
      PRINT_INFO ("    number of columns in matrix A:    "ID"
  ", n_col) ;
      PRINT_INFO ("    entries in matrix A:              "ID"
  ",
  	(Int) Info [UMFPACK_NZ]) ;
      PRINT_INFO ("    memory usage reported in:         "ID"-byte Units
  ",
  	(Int) Info [UMFPACK_SIZE_OF_UNIT]) ;
  
      PRINT_INFO ("    size of int:                      "ID" bytes
  ",
  	(Int) Info [UMFPACK_SIZE_OF_INT]) ;
      PRINT_INFO ("    size of UF_long:                  "ID" bytes
  ",
  	(Int) Info [UMFPACK_SIZE_OF_LONG]) ;
      PRINT_INFO ("    size of pointer:                  "ID" bytes
  ",
  	(Int) Info [UMFPACK_SIZE_OF_POINTER]) ;
      PRINT_INFO ("    size of numerical entry:          "ID" bytes
  ",
  	(Int) Info [UMFPACK_SIZE_OF_ENTRY]) ;
  
      /* ---------------------------------------------------------------------- */
      /* symbolic parameters */
      /* ---------------------------------------------------------------------- */
  
      if (Info [UMFPACK_STRATEGY_USED] == UMFPACK_STRATEGY_SYMMETRIC)
      {
  	PRINTF (("
      strategy used:                    symmetric
  ")) ;
      }
      else if (Info [UMFPACK_STRATEGY_USED] == UMFPACK_STRATEGY_UNSYMMETRIC)
      {
  	PRINTF (("
      strategy used:                    unsymmetric
  ")) ;
      }
      else if (Info [UMFPACK_STRATEGY_USED] == UMFPACK_STRATEGY_2BY2)
      {
  	PRINTF (("
      strategy used:                    symmetric 2-by-2
  "));
      }
  
      if (Info [UMFPACK_ORDERING_USED] == UMFPACK_ORDERING_AMD)
      {
  	PRINTF (("    ordering used:                    amd on A+A'
  ")) ;
      }
      else if (Info [UMFPACK_ORDERING_USED] == UMFPACK_ORDERING_COLAMD)
      {
  	PRINTF (("    ordering used:                    colamd on A
  ")) ;
      }
      else if (Info [UMFPACK_ORDERING_USED] == UMFPACK_ORDERING_GIVEN)
      {
  	PRINTF (("    ordering used:                    provided by user
  ")) ;
      }
  
      if (Info [UMFPACK_QFIXED] == 1)
      {
  	PRINTF (("    modify Q during factorization:    no
  ")) ;
      }
      else if (Info [UMFPACK_QFIXED] == 0)
      {
  	PRINTF (("    modify Q during factorization:    yes
  ")) ;
      }
  
      if (Info [UMFPACK_DIAG_PREFERRED] == 0)
      {
  	PRINTF (("    prefer diagonal pivoting:         no
  ")) ;
      }
      else if (Info [UMFPACK_DIAG_PREFERRED] == 1)
      {
  	PRINTF (("    prefer diagonal pivoting:         yes
  ")) ;
      }
  
      /* ---------------------------------------------------------------------- */
      /* singleton statistics */
      /* ---------------------------------------------------------------------- */
  
      PRINT_INFO ("    pivots with zero Markowitz cost:               %0.f
  ",
  	Info [UMFPACK_COL_SINGLETONS] + Info [UMFPACK_ROW_SINGLETONS]) ;
      PRINT_INFO ("    submatrix S after removing zero-cost pivots:
  "
  		"        number of \"dense\" rows:                    %.0f
  ",
  	Info [UMFPACK_NDENSE_ROW]) ;
      PRINT_INFO ("        number of \"dense\" columns:                 %.0f
  ",
  	Info [UMFPACK_NDENSE_COL]) ;
      PRINT_INFO ("        number of empty rows:                      %.0f
  ",
  	Info [UMFPACK_NEMPTY_ROW]) ;
      PRINT_INFO ("        number of empty columns                    %.0f
  ",
  	Info [UMFPACK_NEMPTY_COL]) ;
      is_sym = Info [UMFPACK_S_SYMMETRIC] ;
      if (is_sym > 0)
      {
  	PRINTF (("        submatrix S square and diagonal preserved
  ")) ;
      }
      else if (is_sym == 0)
      {
  	PRINTF (("        submatrix S not square or diagonal not preserved
  "));
      }
  
      /* ---------------------------------------------------------------------- */
      /* statistics from amd_aat */
      /* ---------------------------------------------------------------------- */
  
      n2 = Info [UMFPACK_N2] ;
      if (n2 >= 0)
      {
  	PRINTF (("    pattern of square submatrix S:
  ")) ;
      }
      PRINT_INFO ("        number rows and columns                    %.0f
  ",
  	n2) ;
      PRINT_INFO ("        symmetry of nonzero pattern:               %.6f
  ",
  	Info [UMFPACK_PATTERN_SYMMETRY]) ;
      PRINT_INFO ("        nz in S+S' (excl. diagonal):               %.0f
  ",
  	Info [UMFPACK_NZ_A_PLUS_AT]) ;
      PRINT_INFO ("        nz on diagonal of matrix S:                %.0f
  ",
  	Info [UMFPACK_NZDIAG]) ;
      if (Info [UMFPACK_NZDIAG] >= 0 && n2 > 0)
      {
  	PRINTF (("        fraction of nz on diagonal:                %.6f
  ",
  	Info [UMFPACK_NZDIAG] / n2)) ;
      }
  
      /* ---------------------------------------------------------------------- */
      /* statistics from 2-by-2 permutation */
      /* ---------------------------------------------------------------------- */
  
      PRINT_INFO ("    2-by-2 pivoting to place large entries on diagonal:
  "
  		"        # of small diagonal entries of S:          %.0f
  ",
  	Info [UMFPACK_2BY2_NWEAK]) ;
      PRINT_INFO ("        # unmatched:                               %.0f
  ",
  	Info [UMFPACK_2BY2_UNMATCHED]) ;
      PRINT_INFO ("        symmetry of P2*S:                          %.6f
  ",
  	Info [UMFPACK_2BY2_PATTERN_SYMMETRY]) ;
      PRINT_INFO ("        nz in P2*S+(P2*S)' (excl. diag.):          %.0f
  ",
  	Info [UMFPACK_2BY2_NZ_PA_PLUS_PAT]) ;
      PRINT_INFO ("        nz on diagonal of P2*S:                    %.0f
  ",
  	Info [UMFPACK_2BY2_NZDIAG]) ;
      if (Info [UMFPACK_2BY2_NZDIAG] >= 0 && n2 > 0)
      {
  	PRINTF (("        fraction of nz on diag of P2*S:            %.6f
  ",
  	Info [UMFPACK_2BY2_NZDIAG] / n2)) ;
      }
  
      /* ---------------------------------------------------------------------- */
      /* statistics from AMD */
      /* ---------------------------------------------------------------------- */
  
      if (Info [UMFPACK_ORDERING_USED] == UMFPACK_ORDERING_AMD)
      {
  	double dmax = Info [UMFPACK_SYMMETRIC_DMAX] ;
  	PRINTF (("    AMD statistics, for strict diagonal pivoting:
  ")) ;
  	PRINT_INFO ("        est. flops for LU factorization:           %.5e
  ",
  	    Info [UMFPACK_SYMMETRIC_FLOPS]) ;
  	PRINT_INFO ("        est. nz in L+U (incl. diagonal):           %.0f
  ",
  	    Info [UMFPACK_SYMMETRIC_LUNZ]) ;
  	PRINT_INFO ("        est. largest front (# entries):            %.0f
  ",
  	    dmax*dmax) ;
  	PRINT_INFO ("        est. max nz in any column of L:            %.0f
  ",
  	    dmax) ;
  	PRINT_INFO (
  	    "        number of \"dense\" rows/columns in S+S':    %.0f
  ",
  	    Info [UMFPACK_SYMMETRIC_NDENSE]) ;
      }
  
      /* ---------------------------------------------------------------------- */
      /* symbolic factorization */
      /* ---------------------------------------------------------------------- */
  
      tsym = Info [UMFPACK_SYMBOLIC_TIME] ;
      twsym = Info [UMFPACK_SYMBOLIC_WALLTIME] ;
  
      PRINT_INFO ("    symbolic factorization defragmentations:       %.0f
  ",
  	Info [UMFPACK_SYMBOLIC_DEFRAG]) ;
      PRINT_INFO ("    symbolic memory usage (Units):                 %.0f
  ",
  	Info [UMFPACK_SYMBOLIC_PEAK_MEMORY]) ;
      PRINT_INFO ("    symbolic memory usage (MBytes):                %.1f
  ",
  	MBYTES (Info [UMFPACK_SYMBOLIC_PEAK_MEMORY])) ;
      PRINT_INFO ("    Symbolic size (Units):                         %.0f
  ",
  	Info [UMFPACK_SYMBOLIC_SIZE]) ;
      PRINT_INFO ("    Symbolic size (MBytes):                        %.0f
  ",
  	MBYTES (Info [UMFPACK_SYMBOLIC_SIZE])) ;
      PRINT_INFO ("    symbolic factorization CPU time (sec):         %.2f
  ",
  	tsym) ;
      PRINT_INFO ("    symbolic factorization wallclock time(sec):    %.2f
  ",
  	twsym) ;
  
      /* ---------------------------------------------------------------------- */
      /* scaling, from numerical factorization */
      /* ---------------------------------------------------------------------- */
  
      if (Info [UMFPACK_WAS_SCALED] == UMFPACK_SCALE_NONE)
      {
  	PRINTF (("
      matrix scaled: no
  ")) ;
      }
      else if (Info [UMFPACK_WAS_SCALED] == UMFPACK_SCALE_SUM)
      {
  	PRINTF (("
      matrix scaled: yes ")) ;
  	PRINTF (("(divided each row by sum of abs values in each row)
  ")) ;
  	PRINTF (("    minimum sum (abs (rows of A)):              %.5e
  ",
  	    Info [UMFPACK_RSMIN])) ;
  	PRINTF (("    maximum sum (abs (rows of A)):              %.5e
  ",
  	    Info [UMFPACK_RSMAX])) ;
      }
      else if (Info [UMFPACK_WAS_SCALED] == UMFPACK_SCALE_MAX)
      {
  	PRINTF (("
      matrix scaled: yes ")) ;
  	PRINTF (("(divided each row by max abs value in each row)
  ")) ;
  	PRINTF (("    minimum max (abs (rows of A)):              %.5e
  ",
  	    Info [UMFPACK_RSMIN])) ;
  	PRINTF (("    maximum max (abs (rows of A)):              %.5e
  ",
  	    Info [UMFPACK_RSMAX])) ;
      }
  
      /* ---------------------------------------------------------------------- */
      /* estimate/actual in symbolic/numeric factorization */
      /* ---------------------------------------------------------------------- */
  
      /* double relop, but ignore NaN case: */
      if (Info [UMFPACK_SYMBOLIC_DEFRAG] >= 0	/* UMFPACK_*symbolic called */
      ||  Info [UMFPACK_NUMERIC_DEFRAG] >= 0)	/* UMFPACK_numeric called */
      {
  	PRINTF (("
      symbolic/numeric factorization:      upper bound")) ;
  	PRINTF (("               actual      %%
  ")) ;
  	PRINTF (("    variable-sized part of Numeric object:
  ")) ;
      }
      print_ratio ("    initial size (Units)", " %20.0f",
  	Info [UMFPACK_VARIABLE_INIT_ESTIMATE], Info [UMFPACK_VARIABLE_INIT]) ;
      print_ratio ("    peak size (Units)", " %20.0f",
  	Info [UMFPACK_VARIABLE_PEAK_ESTIMATE], Info [UMFPACK_VARIABLE_PEAK]) ;
      print_ratio ("    final size (Units)", " %20.0f",
  	Info [UMFPACK_VARIABLE_FINAL_ESTIMATE], Info [UMFPACK_VARIABLE_FINAL]) ;
      print_ratio ("Numeric final size (Units)", " %20.0f",
  	Info [UMFPACK_NUMERIC_SIZE_ESTIMATE], Info [UMFPACK_NUMERIC_SIZE]) ;
      print_ratio ("Numeric final size (MBytes)", " %20.1f",
  	MBYTES (Info [UMFPACK_NUMERIC_SIZE_ESTIMATE]),
  	MBYTES (Info [UMFPACK_NUMERIC_SIZE])) ;
      print_ratio ("peak memory usage (Units)", " %20.0f",
  	Info [UMFPACK_PEAK_MEMORY_ESTIMATE], Info [UMFPACK_PEAK_MEMORY]) ;
      print_ratio ("peak memory usage (MBytes)", " %20.1f",
  	MBYTES (Info [UMFPACK_PEAK_MEMORY_ESTIMATE]),
  	MBYTES (Info [UMFPACK_PEAK_MEMORY])) ;
      print_ratio ("numeric factorization flops", " %20.5e",
  	Info [UMFPACK_FLOPS_ESTIMATE], Info [UMFPACK_FLOPS]) ;
  
      lnz_est = Info [UMFPACK_LNZ_ESTIMATE] ;
      unz_est = Info [UMFPACK_UNZ_ESTIMATE] ;
      if (lnz_est >= 0 && unz_est >= 0)	/* double relop, but ignore NaN case */
      {
  	lunz_est = lnz_est + unz_est - n_inner ;
      }
      else
      {
  	lunz_est = EMPTY ;
      }
      lnz = Info [UMFPACK_LNZ] ;
      unz = Info [UMFPACK_UNZ] ;
      if (lnz >= 0 && unz >= 0)		/* double relop, but ignore NaN case */
      {
  	lunz = lnz + unz - n_inner ;
      }
      else
      {
  	lunz = EMPTY ;
      }
      print_ratio ("nz in L (incl diagonal)", " %20.0f", lnz_est, lnz) ;
      print_ratio ("nz in U (incl diagonal)", " %20.0f", unz_est, unz) ;
      print_ratio ("nz in L+U (incl diagonal)", " %20.0f", lunz_est, lunz) ;
  
      print_ratio ("largest front (# entries)", " %20.0f",
  	Info [UMFPACK_MAX_FRONT_SIZE_ESTIMATE], Info [UMFPACK_MAX_FRONT_SIZE]) ;
      print_ratio ("largest # rows in front", " %20.0f",
  	Info [UMFPACK_MAX_FRONT_NROWS_ESTIMATE],
  	Info [UMFPACK_MAX_FRONT_NROWS]) ;
      print_ratio ("largest # columns in front", " %20.0f",
  	Info [UMFPACK_MAX_FRONT_NCOLS_ESTIMATE],
  	Info [UMFPACK_MAX_FRONT_NCOLS]) ;
  
      /* ---------------------------------------------------------------------- */
      /* numeric factorization */
      /* ---------------------------------------------------------------------- */
  
      tnum = Info [UMFPACK_NUMERIC_TIME] ;
      twnum = Info [UMFPACK_NUMERIC_WALLTIME] ;
      fnum = Info [UMFPACK_FLOPS] ;
  
      PRINT_INFO ("
      initial allocation ratio used:                 %0.3g
  ",
  	Info [UMFPACK_ALLOC_INIT_USED]) ;
      PRINT_INFO ("    # of forced updates due to frontal growth:     %.0f
  ",
  	Info [UMFPACK_FORCED_UPDATES]) ;
      PRINT_INFO ("    number of off-diagonal pivots:                 %.0f
  ",
  	Info [UMFPACK_NOFF_DIAG]) ;
      PRINT_INFO ("    nz in L (incl diagonal), if none dropped       %.0f
  ",
  	Info [UMFPACK_ALL_LNZ]) ;
      PRINT_INFO ("    nz in U (incl diagonal), if none dropped       %.0f
  ",
  	Info [UMFPACK_ALL_UNZ]) ;
      PRINT_INFO ("    number of small entries dropped                %.0f
  ",
  	Info [UMFPACK_NZDROPPED]) ;
      PRINT_INFO ("    nonzeros on diagonal of U:                     %.0f
  ",
  	Info [UMFPACK_UDIAG_NZ]) ;
      PRINT_INFO ("    min abs. value on diagonal of U:               %.2e
  ",
  	Info [UMFPACK_UMIN]) ;
      PRINT_INFO ("    max abs. value on diagonal of U:               %.2e
  ",
  	Info [UMFPACK_UMAX]) ;
      PRINT_INFO ("    estimate of reciprocal of condition number:    %.2e
  ",
  	Info [UMFPACK_RCOND]) ;
      PRINT_INFO ("    indices in compressed pattern:                 %.0f
  ",
  	Info [UMFPACK_COMPRESSED_PATTERN]) ;
      PRINT_INFO ("    numerical values stored in Numeric object:     %.0f
  ",
  	Info [UMFPACK_LU_ENTRIES]) ;
      PRINT_INFO ("    numeric factorization defragmentations:        %.0f
  ",
  	Info [UMFPACK_NUMERIC_DEFRAG]) ;
      PRINT_INFO ("    numeric factorization reallocations:           %.0f
  ",
  	Info [UMFPACK_NUMERIC_REALLOC]) ;
      PRINT_INFO ("    costly numeric factorization reallocations:    %.0f
  ",
  	Info [UMFPACK_NUMERIC_COSTLY_REALLOC]) ;
      PRINT_INFO ("    numeric factorization CPU time (sec):          %.2f
  ",
  	tnum) ;
      PRINT_INFO ("    numeric factorization wallclock time (sec):    %.2f
  ",
  	twnum) ;
  
  #define TMIN 0.001
  
      if (tnum > TMIN && fnum > 0)
      {
  	PRINT_INFO (
  	   "    numeric factorization mflops (CPU time):       %.2f
  ",
  	   1e-6 * fnum / tnum) ;
      }
      if (twnum > TMIN && fnum > 0)
      {
  	PRINT_INFO (
  	   "    numeric factorization mflops (wallclock):      %.2f
  ",
  	   1e-6 * fnum / twnum) ;
      }
  
      ttot = EMPTY ;
      ftot = fnum ;
      if (tsym >= TMIN && tnum >= 0)
      {
  	ttot = tsym + tnum ;
  	PRINT_INFO ("    symbolic + numeric CPU time (sec):             %.2f
  ",
  	    ttot) ;
  	if (ftot > 0 && ttot > TMIN)
  	{
  	    PRINT_INFO (
  		"    symbolic + numeric mflops (CPU time):          %.2f
  ",
  		1e-6 * ftot / ttot) ;
  	}
      }
  
      twtot = EMPTY ;
      if (twsym >= TMIN && twnum >= TMIN)
      {
  	twtot = twsym + twnum ;
  	PRINT_INFO ("    symbolic + numeric wall clock time (sec):      %.2f
  ",
  	    twtot) ;
  	if (ftot > 0 && twtot > TMIN)
  	{
  	    PRINT_INFO (
  		"    symbolic + numeric mflops (wall clock):        %.2f
  ",
  		1e-6 * ftot / twtot) ;
  	}
      }
  
      /* ---------------------------------------------------------------------- */
      /* solve */
      /* ---------------------------------------------------------------------- */
  
      tsolve = Info [UMFPACK_SOLVE_TIME] ;
      twsolve = Info [UMFPACK_SOLVE_WALLTIME] ;
      fsolve = Info [UMFPACK_SOLVE_FLOPS] ;
  
      PRINT_INFO ("
      solve flops:                                   %.5e
  ",
  	fsolve) ;
      PRINT_INFO ("    iterative refinement steps taken:              %.0f
  ",
  	Info [UMFPACK_IR_TAKEN]) ;
      PRINT_INFO ("    iterative refinement steps attempted:          %.0f
  ",
  	Info [UMFPACK_IR_ATTEMPTED]) ;
      PRINT_INFO ("    sparse backward error omega1:                  %.2e
  ",
  	Info [UMFPACK_OMEGA1]) ;
      PRINT_INFO ("    sparse backward error omega2:                  %.2e
  ",
  	Info [UMFPACK_OMEGA2]) ;
      PRINT_INFO ("    solve CPU time (sec):                          %.2f
  ",
  	tsolve) ;
      PRINT_INFO ("    solve wall clock time (sec):                   %.2f
  ",
  	twsolve) ;
      if (fsolve > 0 && tsolve > TMIN)
      {
  	PRINT_INFO (
  	    "    solve mflops (CPU time):                       %.2f
  ",
  	    1e-6 * fsolve / tsolve) ;
      }
      if (fsolve > 0 && twsolve > TMIN)
      {
  	PRINT_INFO (
  	    "    solve mflops (wall clock time):                %.2f
  ",
  	    1e-6 * fsolve / twsolve) ;
      }
  
      if (ftot >= 0 && fsolve >= 0)
      {
  	ftot += fsolve ;
  	PRINT_INFO (
  	"
      total symbolic + numeric + solve flops:        %.5e
  ", ftot) ;
      }
  
      if (tsolve >= TMIN)
      {
  	if (ttot >= TMIN && ftot >= 0)
  	{
  	    ttot += tsolve ;
  	    PRINT_INFO (
  		"    total symbolic + numeric + solve CPU time:     %.2f
  ",
  		ttot) ;
  	    if (ftot > 0 && ttot > TMIN)
  	    {
  		PRINT_INFO (
  		"    total symbolic + numeric + solve mflops (CPU): %.2f
  ",
  		1e-6 * ftot / ttot) ;
  	    }
  	}
      }
  
      if (twsolve >= TMIN)
      {
  	if (twtot >= TMIN && ftot >= 0)
  	{
  	    twtot += tsolve ;
  	    PRINT_INFO (
  		"    total symbolic+numeric+solve wall clock time:  %.2f
  ",
  		twtot) ;
  	    if (ftot > 0 && twtot > TMIN)
  	    {
  		PRINT_INFO (
  		"    total symbolic+numeric+solve mflops(wallclock) %.2f
  ",
  		1e-6 * ftot / twtot) ;
  	    }
  	}
      }
      PRINTF (("
  ")) ;
  }