Mercurial > octave-nkf
comparison liboctave/UMFPACK/UMFPACK/Source/umfpack_report_control.c @ 5164:57077d0ddc8e
[project @ 2005-02-25 19:55:24 by jwe]
author | jwe |
---|---|
date | Fri, 25 Feb 2005 19:55:28 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
5163:9f3299378193 | 5164:57077d0ddc8e |
---|---|
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 | |
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 } |