1 /* ========================================================================== */
2 /* === UMFPACK_report_control =============================================== */
3 /* ========================================================================== */
4
5 /* -------------------------------------------------------------------------- */
6 /* UMFPACK Version 4.4, Copyright (c) 2005 by Timothy A. Davis. CISE Dept, */
7 /* Univ. of Florida. All Rights Reserved. See ../Doc/License for License. */
8 /* web: http://www.cise.ufl.edu/research/sparse/umfpack */
9 /* -------------------------------------------------------------------------- */
10
11 /*
12 User-callable. Prints the control settings. See umfpack_report_control.h
13 for details.
14 */
15
16 #include "umf_internal.h"
17
UMFPACK_report_control(const double Control[UMFPACK_CONTROL])18 GLOBAL void UMFPACK_report_control
19 (
20 const double Control [UMFPACK_CONTROL]
21 )
22 {
23 double drow, dcol, relpt, relpt2, alloc_init, front_alloc_init, amd_alpha,
24 tol, force_fixQ, droptol, aggr ;
25 Int prl, nb, irstep, strategy, scale, s ;
26
27 prl = GET_CONTROL (UMFPACK_PRL, UMFPACK_DEFAULT_PRL) ;
28
29 if (prl < 2)
30 {
31 /* default is to print nothing */
32 return ;
33 }
34
35 PRINTF (("\n%s, Control:\n\n", UMFPACK_VERSION)) ;
36
37 /* ---------------------------------------------------------------------- */
38 /* run-time options */
39 /* ---------------------------------------------------------------------- */
40
41 /* This is a "run-time" option because all four umfpack_* versions */
42 /* compiled into the UMFPACK library. */
43
44 #ifdef DINT
45 PRINTF ((" Matrix entry defined as: double\n")) ;
46 PRINTF ((" Int (generic integer) defined as: int\n")) ;
47 #endif
48 #ifdef DLONG
49 PRINTF ((" Matrix entry defined as: double\n")) ;
50 PRINTF ((" Int (generic integer) defined as: long\n")) ;
51 #endif
52 #ifdef ZINT
53 PRINTF ((" Matrix entry defined as: double complex\n")) ;
54 PRINTF ((" Int (generic integer) defined as: int\n")) ;
55 #endif
56 #ifdef ZLONG
57 PRINTF ((" Matrix entry defined as: double complex\n")) ;
58 PRINTF ((" Int (generic integer) defined as: long\n")) ;
59 #endif
60
61 /* ---------------------------------------------------------------------- */
62 /* printing level */
63 /* ---------------------------------------------------------------------- */
64
65 PRINTF (("\n "ID": print level: "ID"\n",
66 (Int) INDEX (UMFPACK_PRL), prl)) ;
67
68 /* ---------------------------------------------------------------------- */
69 /* dense row/col parameters */
70 /* ---------------------------------------------------------------------- */
71
72 drow = GET_CONTROL (UMFPACK_DENSE_ROW, UMFPACK_DEFAULT_DENSE_ROW) ;
73 dcol = GET_CONTROL (UMFPACK_DENSE_COL, UMFPACK_DEFAULT_DENSE_COL) ;
74
75 PRINTF ((" "ID": dense row parameter: %g\n",
76 (Int) INDEX (UMFPACK_DENSE_ROW), drow)) ;
77 PRINTF ((" \"dense\" rows have > max (16, (%g)*16*sqrt(n_col)"
78 " entries)\n", drow)) ;
79 PRINTF ((" "ID": dense column parameter: %g\n",
80 (Int) INDEX (UMFPACK_DENSE_COL), dcol)) ;
81 PRINTF ((" \"dense\" columns have > max (16, (%g)*16*sqrt(n_row)"
82 " entries)\n", dcol)) ;
83
84 /* ---------------------------------------------------------------------- */
85 /* pivot tolerance */
86 /* ---------------------------------------------------------------------- */
87
88 relpt = GET_CONTROL (UMFPACK_PIVOT_TOLERANCE,
89 UMFPACK_DEFAULT_PIVOT_TOLERANCE) ;
90 relpt = MAX (0.0, MIN (relpt, 1.0)) ;
91 PRINTF ((" "ID": pivot tolerance: %g\n",
92 (Int) INDEX (UMFPACK_PIVOT_TOLERANCE), relpt)) ;
93
94 /* ---------------------------------------------------------------------- */
95 /* block size */
96 /* ---------------------------------------------------------------------- */
97
98 nb = GET_CONTROL (UMFPACK_BLOCK_SIZE, UMFPACK_DEFAULT_BLOCK_SIZE) ;
99 nb = MAX (1, nb) ;
100 PRINTF ((" "ID": block size for dense matrix kernels: "ID"\n",
101 (Int) INDEX (UMFPACK_BLOCK_SIZE), nb)) ;
102
103 /* ---------------------------------------------------------------------- */
104 /* strategy */
105 /* ---------------------------------------------------------------------- */
106
107 strategy = GET_CONTROL (UMFPACK_STRATEGY, UMFPACK_DEFAULT_STRATEGY) ;
108 if (strategy < UMFPACK_STRATEGY_AUTO
109 || strategy > UMFPACK_STRATEGY_SYMMETRIC)
110 {
111 strategy = UMFPACK_STRATEGY_AUTO ;
112 }
113
114 PRINTF ((" "ID": strategy: "ID,
115 (Int) INDEX (UMFPACK_STRATEGY), strategy)) ;
116
117 if (strategy == UMFPACK_STRATEGY_SYMMETRIC)
118 {
119 PRINTF ((" (symmetric)\n"
120 " Q = AMD (A+A'), Q not refined during numerical\n"
121 " factorization, and diagonal pivoting (P=Q') attempted.\n")) ;
122 }
123 else if (strategy == UMFPACK_STRATEGY_UNSYMMETRIC)
124 {
125 PRINTF ((" (unsymmetric)\n"
126 " Q = COLAMD (A), Q refined during numerical\n"
127 " factorization, and no attempt at diagonal pivoting.\n")) ;
128 }
129 else if (strategy == UMFPACK_STRATEGY_2BY2)
130 {
131 PRINTF ((" (symmetric, with 2-by-2 block pivoting)\n"
132 " P2 = row permutation that tries to place large entries on\n"
133 " the diagonal. Q = AMD (P2*A+(P2*A)'), Q not refined during\n"
134 " numerical factorization, attempt to select pivots from the\n"
135 " diagonal of P2*A.\n")) ;
136 }
137 else /* auto strategy */
138 {
139 strategy = UMFPACK_STRATEGY_AUTO ;
140 PRINTF ((" (auto)\n")) ;
141 }
142
143 /* ---------------------------------------------------------------------- */
144 /* initial allocation parameter */
145 /* ---------------------------------------------------------------------- */
146
147 alloc_init = GET_CONTROL (UMFPACK_ALLOC_INIT, UMFPACK_DEFAULT_ALLOC_INIT) ;
148 if (alloc_init >= 0)
149 {
150 PRINTF ((" "ID": initial allocation ratio: %g\n",
151 (Int) INDEX (UMFPACK_ALLOC_INIT), alloc_init)) ;
152 }
153 else
154 {
155 s = -alloc_init ;
156 s = MAX (1, s) ;
157 PRINTF ((" "ID": initial allocation (in Units): "ID"\n",
158 (Int) INDEX (UMFPACK_ALLOC_INIT), s)) ;
159 }
160
161 /* ---------------------------------------------------------------------- */
162 /* maximum iterative refinement steps */
163 /* ---------------------------------------------------------------------- */
164
165 irstep = GET_CONTROL (UMFPACK_IRSTEP, UMFPACK_DEFAULT_IRSTEP) ;
166 irstep = MAX (0, irstep) ;
167 PRINTF ((" "ID": max iterative refinement steps: "ID"\n",
168 (Int) INDEX (UMFPACK_IRSTEP), irstep)) ;
169
170 /* ---------------------------------------------------------------------- */
171 /* 2-by-2 pivot tolerance */
172 /* ---------------------------------------------------------------------- */
173
174 tol = GET_CONTROL (UMFPACK_2BY2_TOLERANCE, UMFPACK_DEFAULT_2BY2_TOLERANCE) ;
175 tol = MAX (0.0, MIN (tol, 1.0)) ;
176 PRINTF ((" "ID": 2-by-2 pivot tolerance: %g\n",
177 (Int) INDEX (UMFPACK_2BY2_TOLERANCE), tol)) ;
178
179 /* ---------------------------------------------------------------------- */
180 /* force fixQ */
181 /* ---------------------------------------------------------------------- */
182
183 force_fixQ = GET_CONTROL (UMFPACK_FIXQ, UMFPACK_DEFAULT_FIXQ) ;
184 PRINTF ((" "ID": Q fixed during numerical factorization: %g ",
185 (Int) INDEX (UMFPACK_FIXQ), force_fixQ)) ;
186 if (force_fixQ > 0)
187 {
188 PRINTF (("(yes)\n")) ;
189 }
190 else if (force_fixQ < 0)
191 {
192 PRINTF (("(no)\n")) ;
193 }
194 else
195 {
196 PRINTF (("(auto)\n")) ;
197 }
198
199 /* ---------------------------------------------------------------------- */
200 /* AMD parameters */
201 /* ---------------------------------------------------------------------- */
202
203 amd_alpha = GET_CONTROL (UMFPACK_AMD_DENSE, UMFPACK_DEFAULT_AMD_DENSE) ;
204 PRINTF ((" "ID": AMD dense row/col parameter: %g\n",
205 (Int) INDEX (UMFPACK_AMD_DENSE), amd_alpha)) ;
206 if (amd_alpha < 0)
207 {
208 PRINTF ((" no \"dense\" rows/columns\n")) ;
209 }
210 else
211 {
212 PRINTF ((" \"dense\" rows/columns have > max (16, (%g)*sqrt(n))"
213 " entries\n", amd_alpha)) ;
214 }
215 PRINTF ((" Only used if the AMD ordering is used.\n")) ;
216
217 /* ---------------------------------------------------------------------- */
218 /* pivot tolerance for symmetric pivoting */
219 /* ---------------------------------------------------------------------- */
220
221 relpt2 = GET_CONTROL (UMFPACK_SYM_PIVOT_TOLERANCE,
222 UMFPACK_DEFAULT_SYM_PIVOT_TOLERANCE) ;
223 relpt2 = MAX (0.0, MIN (relpt2, 1.0)) ;
224 PRINTF ((" "ID": diagonal pivot tolerance: %g\n"
225 " Only used if diagonal pivoting is attempted.\n",
226 (Int) INDEX (UMFPACK_SYM_PIVOT_TOLERANCE), relpt2)) ;
227
228 /* ---------------------------------------------------------------------- */
229 /* scaling */
230 /* ---------------------------------------------------------------------- */
231
232 scale = GET_CONTROL (UMFPACK_SCALE, UMFPACK_DEFAULT_SCALE) ;
233 if (scale != UMFPACK_SCALE_NONE && scale != UMFPACK_SCALE_MAX)
234 {
235 scale = UMFPACK_DEFAULT_SCALE ;
236 }
237 PRINTF ((" "ID": scaling: "ID, (Int) INDEX (UMFPACK_SCALE), scale)) ;
238 if (scale == UMFPACK_SCALE_NONE)
239 {
240 PRINTF ((" (no)")) ;
241 }
242 else if (scale == UMFPACK_SCALE_SUM)
243 {
244 PRINTF ((" (divide each row by sum of abs. values in each row)")) ;
245 }
246 else if (scale == UMFPACK_SCALE_MAX)
247 {
248 PRINTF ((" (divide each row by max. abs. value in each row)")) ;
249 }
250 PRINTF (("\n")) ;
251
252 /* ---------------------------------------------------------------------- */
253 /* frontal matrix allocation parameter */
254 /* ---------------------------------------------------------------------- */
255
256 front_alloc_init = GET_CONTROL (UMFPACK_FRONT_ALLOC_INIT,
257 UMFPACK_DEFAULT_FRONT_ALLOC_INIT) ;
258 front_alloc_init = MIN (1.0, front_alloc_init) ;
259 if (front_alloc_init >= 0)
260 {
261 PRINTF ((" "ID": frontal matrix allocation ratio: %g\n",
262 (Int) INDEX (UMFPACK_FRONT_ALLOC_INIT), front_alloc_init)) ;
263 }
264 else
265 {
266 s = -front_alloc_init ;
267 s = MAX (1, s) ;
268 PRINTF ((" "ID": initial frontal matrix size (# of Entry's): "ID"\n",
269 (Int) INDEX (UMFPACK_FRONT_ALLOC_INIT), s)) ;
270 }
271
272 /* ---------------------------------------------------------------------- */
273 /* drop tolerance */
274 /* ---------------------------------------------------------------------- */
275
276 droptol = GET_CONTROL (UMFPACK_DROPTOL, UMFPACK_DEFAULT_DROPTOL) ;
277 PRINTF ((" "ID": drop tolerance: %g\n",
278 (Int) INDEX (UMFPACK_DROPTOL), droptol)) ;
279
280 /* ---------------------------------------------------------------------- */
281 /* aggressive absorption */
282 /* ---------------------------------------------------------------------- */
283
284 aggr = GET_CONTROL (UMFPACK_AGGRESSIVE, UMFPACK_DEFAULT_AGGRESSIVE) ;
285 PRINTF ((" "ID": AMD and COLAMD aggressive absorption: %g",
286 (Int) INDEX (UMFPACK_AGGRESSIVE), aggr)) ;
287 if (aggr != 0.0)
288 {
289 PRINTF ((" (yes)\n")) ;
290 }
291 else
292 {
293 PRINTF ((" (no)\n")) ;
294 }
295
296 /* ---------------------------------------------------------------------- */
297 /* compile-time options */
298 /* ---------------------------------------------------------------------- */
299
300 PRINTF ((
301 "\n The following options can only be changed at compile-time:\n")) ;
302
303 PRINTF ((" "ID": BLAS library used: ",
304 (Int) INDEX (UMFPACK_COMPILED_WITH_BLAS))) ;
305
306 #if defined (USE_NO_BLAS)
307 PRINTF (("none. UMFPACK will be slow.\n")) ;
308 #elif defined (USE_C_BLAS)
309 PRINTF (("C-BLAS.\n")) ;
310 #elif defined (USE_MATLAB_BLAS)
311 PRINTF (("built-in MATLAB BLAS (ATLAS).\n")) ;
312 #elif defined (USE_SUNPERF_BLAS)
313 PRINTF (("Sun Performance Library BLAS.\n")) ;
314 #elif defined (USE_SCSL_BLAS)
315 PRINTF (("SGI SCSL BLAS.\n")) ;
316 #elif defined (USE_FORTRAN_BLAS)
317 PRINTF (("Fortran BLAS.\n")) ;
318 #endif
319
320 #ifdef MATLAB_MEX_FILE
321 #ifdef NUTIL
322 PRINTF ((" "ID": compiled for MATLAB"
323 " (uses mxMalloc, mxFree, mxRealloc, and mexPrintf)\n",
324 (Int) INDEX (UMFPACK_COMPILED_FOR_MATLAB))) ;
325 #else
326 PRINTF ((" "ID": compiled for MATLAB"
327 " (uses utMalloc, utFree, utRealloc, and mexPrintf)\n",
328 (Int) INDEX (UMFPACK_COMPILED_FOR_MATLAB))) ;
329 #endif
330 #else
331 #ifdef MATHWORKS
332 PRINTF ((" "ID": compiled for MATLAB, using internal utility routines\n"
333 " (uses utMalloc, utFree, utRealloc, and utPrintf)\n",
334 (Int) INDEX (UMFPACK_COMPILED_FOR_MATLAB))) ;
335 PRINTF ((" (complex version uses utDivideComplex, utFdlibm_hypot)\n")) ;
336 #else
337 PRINTF ((" "ID": compiled for ANSI C"
338 " (uses malloc, free, realloc, and printf)\n",
339 (Int) INDEX (UMFPACK_COMPILED_FOR_MATLAB))) ;
340 #endif
341 #endif
342
343 #ifdef NO_TIMER
344 PRINTF ((" "ID": no CPU timer \n",
345 (Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
346 #else
347 #ifndef NPOSIX
348 PRINTF ((" "ID": CPU timer is POSIX times ( ) routine.\n",
349 (Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
350 #else
351 #ifdef GETRUSAGE
352 PRINTF ((" "ID": CPU timer is getrusage.\n",
353 (Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
354 #else
355 PRINTF ((" "ID": CPU timer is ANSI C clock (may wrap around).\n",
356 (Int) INDEX (UMFPACK_COMPILED_WITH_GETRUSAGE))) ;
357 #endif
358 #endif
359 #endif
360
361 #ifndef NDEBUG
362 PRINTF ((
363 "**** Debugging enabled (UMFPACK will be exceedingly slow!) *****************\n"
364 " "ID": compiled with debugging enabled. ",
365 (Int) INDEX (UMFPACK_COMPILED_IN_DEBUG_MODE))) ;
366 #ifdef MATLAB_MEX_FILE
367 PRINTF (("Uses mxAssert.\n")) ;
368 #else
369 #ifdef MATHWORKS
370 PRINTF (("Uses utAssert.\n")) ;
371 #else
372 PRINTF (("Uses ANSI C assert.\n")) ;
373 #endif
374 #endif
375 #else
376 PRINTF ((" "ID": compiled for normal operation (debugging disabled)\n",
377 (Int) INDEX (UMFPACK_COMPILED_IN_DEBUG_MODE))) ;
378 #endif
379
380 PRINTF ((" computer/operating system: %s\n", UMFPACK_ARCHITECTURE)) ;
381 PRINTF ((" size of int: %g long: %g Int: %g pointer: %g"
382 " double: %g Entry: %g (in bytes)\n\n", (double) sizeof (int),
383 (double) sizeof (long), (double) sizeof (Int),
384 (double) sizeof (void *), (double) sizeof (double),
385 (double) sizeof (Entry))) ;
386 }
387