1 /* ========================================================================== */
2 /* === UMFPACK_report_control =============================================== */
3 /* ========================================================================== */
4
5 /* -------------------------------------------------------------------------- */
6 /* Copyright (c) 2005-2012 by Timothy A. Davis, http://www.suitesparse.com. */
7 /* All Rights Reserved. See ../Doc/License.txt for License. */
8 /* -------------------------------------------------------------------------- */
9
10 /*
11 User-callable. Prints the control settings. See umfpack_report_control.h
12 for details.
13 */
14
15 #include "umf_internal.h"
16
UMFPACK_report_control(const double Control[UMFPACK_CONTROL])17 GLOBAL void UMFPACK_report_control
18 (
19 const double Control [UMFPACK_CONTROL]
20 )
21 {
22 double drow, dcol, relpt, relpt2, alloc_init, front_alloc_init, amd_alpha,
23 force_fixQ, droptol, aggr ;
24 Int prl, nb, irstep, strategy, scale, s ;
25 Int do_singletons, ordering_option ;
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 (("UMFPACK V%d.%d.%d (%s), Control:\n", UMFPACK_MAIN_VERSION,
36 UMFPACK_SUB_VERSION, UMFPACK_SUBSUB_VERSION, UMFPACK_DATE)) ;
37
38 /* ---------------------------------------------------------------------- */
39 /* run-time options */
40 /* ---------------------------------------------------------------------- */
41
42 /* This is a "run-time" option because all four umfpack_* versions */
43 /* compiled into the UMFPACK library. */
44
45 #ifdef DINT
46 PRINTF ((" Matrix entry defined as: double\n")) ;
47 PRINTF ((" Int (generic integer) defined as: int\n")) ;
48 #endif
49 #ifdef DLONG
50 PRINTF ((" Matrix entry defined as: double\n")) ;
51 PRINTF ((" Int (generic integer) defined as: SuiteSparse_long\n")) ;
52 #endif
53 #ifdef ZINT
54 PRINTF ((" Matrix entry defined as: double complex\n")) ;
55 PRINTF ((" Int (generic integer) defined as: int\n")) ;
56 #endif
57 #ifdef ZLONG
58 PRINTF ((" Matrix entry defined as: double complex\n")) ;
59 PRINTF ((" Int (generic integer) defined as: SuiteSparse_long\n")) ;
60 #endif
61
62 /* ---------------------------------------------------------------------- */
63 /* printing level */
64 /* ---------------------------------------------------------------------- */
65
66 PRINTF (("\n "ID": print level: "ID"\n",
67 (Int) INDEX (UMFPACK_PRL), prl)) ;
68
69 /* ---------------------------------------------------------------------- */
70 /* dense row/col parameters */
71 /* ---------------------------------------------------------------------- */
72
73 drow = GET_CONTROL (UMFPACK_DENSE_ROW, UMFPACK_DEFAULT_DENSE_ROW) ;
74 dcol = GET_CONTROL (UMFPACK_DENSE_COL, UMFPACK_DEFAULT_DENSE_COL) ;
75
76 PRINTF ((" "ID": dense row parameter: %g\n",
77 (Int) INDEX (UMFPACK_DENSE_ROW), drow)) ;
78 PRINTF ((" \"dense\" rows have > max (16, (%g)*16*sqrt(n_col)"
79 " entries)\n", drow)) ;
80 PRINTF ((" "ID": dense column parameter: %g\n",
81 (Int) INDEX (UMFPACK_DENSE_COL), dcol)) ;
82 PRINTF ((" \"dense\" columns have > max (16, (%g)*16*sqrt(n_row)"
83 " entries)\n", dcol)) ;
84
85 /* ---------------------------------------------------------------------- */
86 /* pivot tolerance */
87 /* ---------------------------------------------------------------------- */
88
89 relpt = GET_CONTROL (UMFPACK_PIVOT_TOLERANCE,
90 UMFPACK_DEFAULT_PIVOT_TOLERANCE) ;
91 relpt = MAX (0.0, MIN (relpt, 1.0)) ;
92 PRINTF ((" "ID": pivot tolerance: %g\n",
93 (Int) INDEX (UMFPACK_PIVOT_TOLERANCE), relpt)) ;
94
95 /* ---------------------------------------------------------------------- */
96 /* block size */
97 /* ---------------------------------------------------------------------- */
98
99 nb = GET_CONTROL (UMFPACK_BLOCK_SIZE, UMFPACK_DEFAULT_BLOCK_SIZE) ;
100 nb = MAX (1, nb) ;
101 PRINTF ((" "ID": block size for dense matrix kernels: "ID"\n",
102 (Int) INDEX (UMFPACK_BLOCK_SIZE), nb)) ;
103
104 /* ---------------------------------------------------------------------- */
105 /* strategy */
106 /* ---------------------------------------------------------------------- */
107
108 strategy = GET_CONTROL (UMFPACK_STRATEGY, UMFPACK_DEFAULT_STRATEGY) ;
109 if (strategy < UMFPACK_STRATEGY_AUTO
110 || strategy > UMFPACK_STRATEGY_SYMMETRIC)
111 {
112 strategy = UMFPACK_STRATEGY_AUTO ;
113 }
114
115 PRINTF ((" "ID": strategy: "ID,
116 (Int) INDEX (UMFPACK_STRATEGY), strategy)) ;
117
118 if (strategy == UMFPACK_STRATEGY_SYMMETRIC)
119 {
120 PRINTF ((" (symmetric)\n"
121 " Q = AMD (A+A'), Q not refined during numerical\n"
122 " factorization, and diagonal pivoting (P=Q') attempted.\n")) ;
123 }
124 else if (strategy == UMFPACK_STRATEGY_UNSYMMETRIC)
125 {
126 PRINTF ((" (unsymmetric)\n"
127 " Q = COLAMD (A), Q refined during numerical\n"
128 " factorization, and no attempt at diagonal pivoting.\n")) ;
129 }
130 else /* auto strategy */
131 {
132 strategy = UMFPACK_STRATEGY_AUTO ;
133 PRINTF ((" (auto)\n")) ;
134 }
135
136 /* ---------------------------------------------------------------------- */
137 /* ordering */
138 /* ---------------------------------------------------------------------- */
139
140 ordering_option = GET_CONTROL (UMFPACK_ORDERING, UMFPACK_DEFAULT_ORDERING) ;
141 if (ordering_option < 0 || ordering_option > UMFPACK_ORDERING_USER)
142 {
143 ordering_option = UMFPACK_DEFAULT_ORDERING ;
144 }
145 PRINTF ((" "ID": ordering: "ID,
146 (Int) INDEX (UMFPACK_ORDERING), ordering_option)) ;
147 if (ordering_option == UMFPACK_ORDERING_CHOLMOD)
148 {
149 PRINTF ((" CHOLMOD: AMD/COLAMD, then try METIS, and select best\n")) ;
150 }
151 else if (ordering_option == UMFPACK_ORDERING_AMD)
152 {
153 PRINTF ((" AMD/COLAMD\n")) ;
154 }
155 else if (ordering_option == UMFPACK_ORDERING_GIVEN)
156 {
157 PRINTF ((" user-provided permutation vector\n")) ;
158 }
159 else if (ordering_option == UMFPACK_ORDERING_NONE)
160 {
161 PRINTF ((" none\n")) ;
162 }
163 else if (ordering_option == UMFPACK_ORDERING_METIS)
164 {
165 PRINTF ((" METIS\n")) ;
166 }
167 else if (ordering_option == UMFPACK_ORDERING_BEST)
168 {
169 PRINTF ((" best effort. Try AMD/COLAMD and METIS, select best\n")) ;
170 }
171 else if (ordering_option == UMFPACK_ORDERING_USER)
172 {
173 PRINTF ((" user-provided ordering function\n")) ;
174 }
175
176 /* ---------------------------------------------------------------------- */
177 /* disable singletons (default is FALSE) */
178 /* ---------------------------------------------------------------------- */
179
180 do_singletons = GET_CONTROL (UMFPACK_SINGLETONS,UMFPACK_DEFAULT_SINGLETONS);
181 PRINTF ((" "ID": singleton filter:", (Int) INDEX (UMFPACK_SINGLETONS))) ;
182 if (do_singletons)
183 {
184 PRINTF ((" enabled\n")) ;
185 }
186 else
187 {
188 PRINTF ((" disabled\n")) ;
189 }
190
191 /* ---------------------------------------------------------------------- */
192 /* initial allocation parameter */
193 /* ---------------------------------------------------------------------- */
194
195 alloc_init = GET_CONTROL (UMFPACK_ALLOC_INIT, UMFPACK_DEFAULT_ALLOC_INIT) ;
196 if (alloc_init >= 0)
197 {
198 PRINTF ((" "ID": initial allocation ratio: %g\n",
199 (Int) INDEX (UMFPACK_ALLOC_INIT), alloc_init)) ;
200 }
201 else
202 {
203 s = -alloc_init ;
204 s = MAX (1, s) ;
205 PRINTF ((" "ID": initial allocation (in Units): "ID"\n",
206 (Int) INDEX (UMFPACK_ALLOC_INIT), s)) ;
207 }
208
209 /* ---------------------------------------------------------------------- */
210 /* maximum iterative refinement steps */
211 /* ---------------------------------------------------------------------- */
212
213 irstep = GET_CONTROL (UMFPACK_IRSTEP, UMFPACK_DEFAULT_IRSTEP) ;
214 irstep = MAX (0, irstep) ;
215 PRINTF ((" "ID": max iterative refinement steps: "ID"\n",
216 (Int) INDEX (UMFPACK_IRSTEP), irstep)) ;
217
218 /* ---------------------------------------------------------------------- */
219 /* force fixQ */
220 /* ---------------------------------------------------------------------- */
221
222 force_fixQ = GET_CONTROL (UMFPACK_FIXQ, UMFPACK_DEFAULT_FIXQ) ;
223 PRINTF ((" "ID": Q fixed during numerical factorization: %g ",
224 (Int) INDEX (UMFPACK_FIXQ), force_fixQ)) ;
225 if (force_fixQ > 0)
226 {
227 PRINTF (("(yes)\n")) ;
228 }
229 else if (force_fixQ < 0)
230 {
231 PRINTF (("(no)\n")) ;
232 }
233 else
234 {
235 PRINTF (("(auto)\n")) ;
236 }
237
238 /* ---------------------------------------------------------------------- */
239 /* AMD parameters */
240 /* ---------------------------------------------------------------------- */
241
242 amd_alpha = GET_CONTROL (UMFPACK_AMD_DENSE, UMFPACK_DEFAULT_AMD_DENSE) ;
243 PRINTF ((" "ID": AMD dense row/col parameter: %g\n",
244 (Int) INDEX (UMFPACK_AMD_DENSE), amd_alpha)) ;
245 if (amd_alpha < 0)
246 {
247 PRINTF ((" no \"dense\" rows/columns\n")) ;
248 }
249 else
250 {
251 PRINTF ((" \"dense\" rows/columns have > max (16, (%g)*sqrt(n))"
252 " entries\n", amd_alpha)) ;
253 }
254 PRINTF ((" Only used if the AMD ordering is used.\n")) ;
255
256 /* ---------------------------------------------------------------------- */
257 /* pivot tolerance for symmetric pivoting */
258 /* ---------------------------------------------------------------------- */
259
260 relpt2 = GET_CONTROL (UMFPACK_SYM_PIVOT_TOLERANCE,
261 UMFPACK_DEFAULT_SYM_PIVOT_TOLERANCE) ;
262 relpt2 = MAX (0.0, MIN (relpt2, 1.0)) ;
263 PRINTF ((" "ID": diagonal pivot tolerance: %g\n"
264 " Only used if diagonal pivoting is attempted.\n",
265 (Int) INDEX (UMFPACK_SYM_PIVOT_TOLERANCE), relpt2)) ;
266
267 /* ---------------------------------------------------------------------- */
268 /* scaling */
269 /* ---------------------------------------------------------------------- */
270
271 scale = GET_CONTROL (UMFPACK_SCALE, UMFPACK_DEFAULT_SCALE) ;
272 if (scale != UMFPACK_SCALE_NONE && scale != UMFPACK_SCALE_MAX)
273 {
274 scale = UMFPACK_DEFAULT_SCALE ;
275 }
276 PRINTF ((" "ID": scaling: "ID, (Int) INDEX (UMFPACK_SCALE), scale)) ;
277 if (scale == UMFPACK_SCALE_NONE)
278 {
279 PRINTF ((" (no)")) ;
280 }
281 else if (scale == UMFPACK_SCALE_SUM)
282 {
283 PRINTF ((" (divide each row by sum of abs. values in each row)")) ;
284 }
285 else if (scale == UMFPACK_SCALE_MAX)
286 {
287 PRINTF ((" (divide each row by max. abs. value in each row)")) ;
288 }
289 PRINTF (("\n")) ;
290
291 /* ---------------------------------------------------------------------- */
292 /* frontal matrix allocation parameter */
293 /* ---------------------------------------------------------------------- */
294
295 front_alloc_init = GET_CONTROL (UMFPACK_FRONT_ALLOC_INIT,
296 UMFPACK_DEFAULT_FRONT_ALLOC_INIT) ;
297 front_alloc_init = MIN (1.0, front_alloc_init) ;
298 if (front_alloc_init >= 0)
299 {
300 PRINTF ((" "ID": frontal matrix allocation ratio: %g\n",
301 (Int) INDEX (UMFPACK_FRONT_ALLOC_INIT), front_alloc_init)) ;
302 }
303 else
304 {
305 s = -front_alloc_init ;
306 s = MAX (1, s) ;
307 PRINTF ((" "ID": initial frontal matrix size (# of Entry's): "ID"\n",
308 (Int) INDEX (UMFPACK_FRONT_ALLOC_INIT), s)) ;
309 }
310
311 /* ---------------------------------------------------------------------- */
312 /* drop tolerance */
313 /* ---------------------------------------------------------------------- */
314
315 droptol = GET_CONTROL (UMFPACK_DROPTOL, UMFPACK_DEFAULT_DROPTOL) ;
316 PRINTF ((" "ID": drop tolerance: %g\n",
317 (Int) INDEX (UMFPACK_DROPTOL), droptol)) ;
318
319 /* ---------------------------------------------------------------------- */
320 /* aggressive absorption */
321 /* ---------------------------------------------------------------------- */
322
323 aggr = GET_CONTROL (UMFPACK_AGGRESSIVE, UMFPACK_DEFAULT_AGGRESSIVE) ;
324 PRINTF ((" "ID": AMD and COLAMD aggressive absorption: %g",
325 (Int) INDEX (UMFPACK_AGGRESSIVE), aggr)) ;
326 if (aggr != 0.0)
327 {
328 PRINTF ((" (yes)\n")) ;
329 }
330 else
331 {
332 PRINTF ((" (no)\n")) ;
333 }
334
335 /* ---------------------------------------------------------------------- */
336 /* compile-time options */
337 /* ---------------------------------------------------------------------- */
338
339 PRINTF ((
340 "\n The following options can only be changed at compile-time:\n")) ;
341
342 PRINTF ((" "ID": BLAS library used: ",
343 (Int) INDEX (UMFPACK_COMPILED_WITH_BLAS))) ;
344
345 #ifdef NBLAS
346 PRINTF (("none. UMFPACK will be slow.\n")) ;
347 #else
348 PRINTF (("Fortran BLAS. size of BLAS integer: "ID"\n",
349 (Int) (sizeof (BLAS_INT)))) ;
350 #endif
351
352 #ifdef MATLAB_MEX_FILE
353 PRINTF ((" compiled for MATLAB\n")) ;
354 #else
355 PRINTF ((" compiled for ANSI C\n")) ;
356 #endif
357
358 #ifdef SUITESPARSE_TIMER_ENABLED
359 PRINTF ((" POSIX C clock_getttime.\n")) ;
360 #else
361 PRINTF ((" no timer used.\n")) ;
362 #endif
363
364 PRINTF ((" computer/operating system: %s\n", UMFPACK_ARCHITECTURE)) ;
365 PRINTF ((" size of int: %g SuiteSparse_long: %g Int: %g pointer: %g"
366 " double: %g Entry: %g (in bytes)\n\n", (double) sizeof (int),
367 (double) sizeof (SuiteSparse_long), (double) sizeof (Int),
368 (double) sizeof (void *), (double) sizeof (double),
369 (double) sizeof (Entry))) ;
370 }
371