Mercurial > octave-nkf
comparison liboctave/UMFPACK/UMFPACK/Include/umfpack_symbolic.h @ 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_symbolic ===================================================== */ | |
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 int umfpack_di_symbolic | |
12 ( | |
13 int n_row, | |
14 int n_col, | |
15 const int Ap [ ], | |
16 const int Ai [ ], | |
17 const double Ax [ ], | |
18 void **Symbolic, | |
19 const double Control [UMFPACK_CONTROL], | |
20 double Info [UMFPACK_INFO] | |
21 ) ; | |
22 | |
23 long umfpack_dl_symbolic | |
24 ( | |
25 long n_row, | |
26 long n_col, | |
27 const long Ap [ ], | |
28 const long Ai [ ], | |
29 const double Ax [ ], | |
30 void **Symbolic, | |
31 const double Control [UMFPACK_CONTROL], | |
32 double Info [UMFPACK_INFO] | |
33 ) ; | |
34 | |
35 int umfpack_zi_symbolic | |
36 ( | |
37 int n_row, | |
38 int n_col, | |
39 const int Ap [ ], | |
40 const int Ai [ ], | |
41 const double Ax [ ], const double Az [ ], | |
42 void **Symbolic, | |
43 const double Control [UMFPACK_CONTROL], | |
44 double Info [UMFPACK_INFO] | |
45 ) ; | |
46 | |
47 long umfpack_zl_symbolic | |
48 ( | |
49 long n_row, | |
50 long n_col, | |
51 const long Ap [ ], | |
52 const long Ai [ ], | |
53 const double Ax [ ], const double Az [ ], | |
54 void **Symbolic, | |
55 const double Control [UMFPACK_CONTROL], | |
56 double Info [UMFPACK_INFO] | |
57 ) ; | |
58 | |
59 /* | |
60 double int Syntax: | |
61 | |
62 #include "umfpack.h" | |
63 void *Symbolic ; | |
64 int n_row, n_col, *Ap, *Ai, status ; | |
65 double Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], *Ax ; | |
66 status = umfpack_di_symbolic (n_row, n_col, Ap, Ai, Ax, | |
67 &Symbolic, Control, Info) ; | |
68 | |
69 double long Syntax: | |
70 | |
71 #include "umfpack.h" | |
72 void *Symbolic ; | |
73 long n_row, n_col, *Ap, *Ai, status ; | |
74 double Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], *Ax ; | |
75 status = umfpack_dl_symbolic (n_row, n_col, Ap, Ai, Ax, | |
76 &Symbolic, Control, Info) ; | |
77 | |
78 complex int Syntax: | |
79 | |
80 #include "umfpack.h" | |
81 void *Symbolic ; | |
82 int n_row, n_col, *Ap, *Ai, status ; | |
83 double Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], *Ax, *Az ; | |
84 status = umfpack_zi_symbolic (n_row, n_col, Ap, Ai, Ax, Az, | |
85 &Symbolic, Control, Info) ; | |
86 | |
87 complex long Syntax: | |
88 | |
89 #include "umfpack.h" | |
90 void *Symbolic ; | |
91 long n_row, n_col, *Ap, *Ai, status ; | |
92 double Control [UMFPACK_CONTROL], Info [UMFPACK_INFO], *Ax, *Az ; | |
93 status = umfpack_zl_symbolic (n_row, n_col, Ap, Ai, Ax, Az, | |
94 &Symbolic, Control, Info) ; | |
95 | |
96 packed complex Syntax: | |
97 | |
98 Same as above, except Az is NULL. | |
99 | |
100 Purpose: | |
101 | |
102 Given nonzero pattern of a sparse matrix A in column-oriented form, | |
103 umfpack_*_symbolic performs a column pre-ordering to reduce fill-in | |
104 (using COLAMD or AMD) and a symbolic factorization. This is required | |
105 before the matrix can be numerically factorized with umfpack_*_numeric. | |
106 If you wish to bypass the COLAMD or AMD pre-ordering and provide your own | |
107 ordering, use umfpack_*_qsymbolic instead. | |
108 | |
109 Since umfpack_*_symbolic and umfpack_*_qsymbolic are very similar, options | |
110 for both routines are discussed below. | |
111 | |
112 For the following discussion, let S be the submatrix of A obtained after | |
113 eliminating all pivots of zero Markowitz cost. S has dimension | |
114 (n_row-n1-nempty_row) -by- (n_col-n1-nempty_col), where | |
115 n1 = Info [UMFPACK_COL_SINGLETONS] + Info [UMFPACK_ROW_SINGLETONS], | |
116 nempty_row = Info [UMFPACK_NEMPTY_ROW] and | |
117 nempty_col = Info [UMFPACK_NEMPTY_COL]. | |
118 | |
119 Returns: | |
120 | |
121 The status code is returned. See Info [UMFPACK_STATUS], below. | |
122 | |
123 Arguments: | |
124 | |
125 Int n_row ; Input argument, not modified. | |
126 Int n_col ; Input argument, not modified. | |
127 | |
128 A is an n_row-by-n_col matrix. Restriction: n_row > 0 and n_col > 0. | |
129 | |
130 Int Ap [n_col+1] ; Input argument, not modified. | |
131 | |
132 Ap is an integer array of size n_col+1. On input, it holds the | |
133 "pointers" for the column form of the sparse matrix A. Column j of | |
134 the matrix A is held in Ai [(Ap [j]) ... (Ap [j+1]-1)]. The first | |
135 entry, Ap [0], must be zero, and Ap [j] <= Ap [j+1] must hold for all | |
136 j in the range 0 to n_col-1. The value nz = Ap [n_col] is thus the | |
137 total number of entries in the pattern of the matrix A. nz must be | |
138 greater than or equal to zero. | |
139 | |
140 Int Ai [nz] ; Input argument, not modified, of size nz = Ap [n_col]. | |
141 | |
142 The nonzero pattern (row indices) for column j is stored in | |
143 Ai [(Ap [j]) ... (Ap [j+1]-1)]. The row indices in a given column j | |
144 must be in ascending order, and no duplicate row indices may be present. | |
145 Row indices must be in the range 0 to n_row-1 (the matrix is 0-based). | |
146 See umfpack_*_triplet_to_col for how to sort the columns of a matrix | |
147 and sum up the duplicate entries. See umfpack_*_report_matrix for how | |
148 to print the matrix A. | |
149 | |
150 double Ax [nz] ; Optional input argument, not modified. | |
151 Size 2*nz for packed complex case. | |
152 | |
153 The numerical values of the sparse matrix A. The nonzero pattern (row | |
154 indices) for column j is stored in Ai [(Ap [j]) ... (Ap [j+1]-1)], and | |
155 the corresponding numerical values are stored in | |
156 Ax [(Ap [j]) ... (Ap [j+1]-1)]. Used only by the 2-by-2 strategy to | |
157 determine whether entries are "large" or "small". You do not have to | |
158 pass the same numerical values to umfpack_*_numeric. If Ax is not | |
159 present (a (double *) NULL pointer), then any entry in A is assumed to | |
160 be "large". | |
161 | |
162 double Az [nz] ; Optional input argument, not modified, for complex | |
163 versions. | |
164 | |
165 For the complex versions, this holds the imaginary part of A. The | |
166 imaginary part of column j is held in Az [(Ap [j]) ... (Ap [j+1]-1)]. | |
167 | |
168 If Az is NULL, then both real | |
169 and imaginary parts are contained in Ax[0..2*nz-1], with Ax[2*k] | |
170 and Ax[2*k+1] being the real and imaginary part of the kth entry. | |
171 | |
172 Used by the 2-by-2 strategy only. See the description of Ax, above. | |
173 | |
174 void **Symbolic ; Output argument. | |
175 | |
176 **Symbolic is the address of a (void *) pointer variable in the user's | |
177 calling routine (see Syntax, above). On input, the contents of this | |
178 variable are not defined. On output, this variable holds a (void *) | |
179 pointer to the Symbolic object (if successful), or (void *) NULL if | |
180 a failure occurred. | |
181 | |
182 double Control [UMFPACK_CONTROL] ; Input argument, not modified. | |
183 | |
184 If a (double *) NULL pointer is passed, then the default control | |
185 settings are used (the defaults are suitable for all matrices, | |
186 ranging from those with highly unsymmetric nonzero pattern, to | |
187 symmetric matrices). Otherwise, the settings are determined from the | |
188 Control array. See umfpack_*_defaults on how to fill the Control | |
189 array with the default settings. If Control contains NaN's, the | |
190 defaults are used. The following Control parameters are used: | |
191 | |
192 Control [UMFPACK_STRATEGY]: This is the most important control | |
193 parameter. It determines what kind of ordering and pivoting | |
194 strategy that UMFPACK should use. There are 4 options: | |
195 | |
196 UMFPACK_STRATEGY_AUTO: This is the default. The input matrix is | |
197 analyzed to determine how symmetric the nonzero pattern is, and | |
198 how many entries there are on the diagonal. It then selects one | |
199 of the following strategies. Refer to the User Guide for a | |
200 description of how the strategy is automatically selected. | |
201 | |
202 UMFPACK_STRATEGY_UNSYMMETRIC: Use the unsymmetric strategy. COLAMD | |
203 is used to order the columns of A, followed by a postorder of | |
204 the column elimination tree. No attempt is made to perform | |
205 diagonal pivoting. The column ordering is refined during | |
206 factorization. | |
207 | |
208 In the numerical factorization, the | |
209 Control [UMFPACK_SYM_PIVOT_TOLERANCE] parameter is ignored. A | |
210 pivot is selected if its magnitude is >= | |
211 Control [UMFPACK_PIVOT_TOLERANCE] (default 0.1) times the | |
212 largest entry in its column. | |
213 | |
214 UMFPACK_STRATEGY_SYMMETRIC: Use the symmetric strategy | |
215 In this method, the approximate minimum degree | |
216 ordering (AMD) is applied to A+A', followed by a postorder of | |
217 the elimination tree of A+A'. UMFPACK attempts to perform | |
218 diagonal pivoting during numerical factorization. No refinement | |
219 of the column pre-ordering is performed during factorization. | |
220 | |
221 In the numerical factorization, a nonzero entry on the diagonal | |
222 is selected as the pivot if its magnitude is >= Control | |
223 [UMFPACK_SYM_PIVOT_TOLERANCE] (default 0.001) times the largest | |
224 entry in its column. If this is not acceptable, then an | |
225 off-diagonal pivot is selected with magnitude >= Control | |
226 [UMFPACK_PIVOT_TOLERANCE] (default 0.1) times the largest entry | |
227 in its column. | |
228 | |
229 UMFPACK_STRATEGY_2BY2: a row permutation P2 is found that places | |
230 large entries on the diagonal. The matrix P2*A is then | |
231 factorized using the symmetric strategy, described above. | |
232 Refer to the User Guide for more information. | |
233 | |
234 Control [UMFPACK_DENSE_COL]: | |
235 If COLAMD is used, columns with more than | |
236 max (16, Control [UMFPACK_DENSE_COL] * 16 * sqrt (n_row)) entries | |
237 are placed placed last in the column pre-ordering. Default: 0.2. | |
238 | |
239 Control [UMFPACK_DENSE_ROW]: | |
240 Rows with more than max (16, Control [UMFPACK_DENSE_ROW] * 16 * | |
241 sqrt (n_col)) entries are treated differently in the COLAMD | |
242 pre-ordering, and in the internal data structures during the | |
243 subsequent numeric factorization. Default: 0.2. | |
244 | |
245 Control [UMFPACK_AMD_DENSE]: rows/columns in A+A' with more than | |
246 max (16, Control [UMFPACK_AMD_DENSE] * sqrt (n)) entries | |
247 (where n = n_row = n_col) are ignored in the AMD pre-ordering. | |
248 Default: 10. | |
249 | |
250 Control [UMFPACK_BLOCK_SIZE]: the block size to use for Level-3 BLAS | |
251 in the subsequent numerical factorization (umfpack_*_numeric). | |
252 A value less than 1 is treated as 1. Default: 32. Modifying this | |
253 parameter affects when updates are applied to the working frontal | |
254 matrix, and can indirectly affect fill-in and operation count. | |
255 As long as the block size is large enough (8 or so), this parameter | |
256 has a modest effect on performance. | |
257 | |
258 Control [UMFPACK_2BY2_TOLERANCE]: a diagonal entry S (k,k) is | |
259 considered "small" if it is < tol * max (abs (S (:,k))), where S a | |
260 submatrix of the scaled input matrix, with pivots of zero Markowitz | |
261 cost removed. | |
262 | |
263 Control [UMFPACK_SCALE]: See umfpack_numeric.h for a description. | |
264 Only affects the 2-by-2 strategy. Default: UMFPACK_SCALE_SUM. | |
265 | |
266 Control [UMFPACK_FIXQ]: If > 0, then the pre-ordering Q is not modified | |
267 during numeric factorization. If < 0, then Q may be modified. If | |
268 zero, then this is controlled automatically (the unsymmetric | |
269 strategy modifies Q, the others do not). Default: 0. | |
270 | |
271 Control [UMFPACK_AGGRESSIVE]: If nonzero, aggressive absorption is used | |
272 in COLAMD and AMD. Default: 1. | |
273 | |
274 double Info [UMFPACK_INFO] ; Output argument, not defined on input. | |
275 | |
276 Contains statistics about the symbolic analysis. If a (double *) NULL | |
277 pointer is passed, then no statistics are returned in Info (this is not | |
278 an error condition). The entire Info array is cleared (all entries set | |
279 to -1) and then the following statistics are computed: | |
280 | |
281 Info [UMFPACK_STATUS]: status code. This is also the return value, | |
282 whether or not Info is present. | |
283 | |
284 UMFPACK_OK | |
285 | |
286 Each column of the input matrix contained row indices | |
287 in increasing order, with no duplicates. Only in this case | |
288 does umfpack_*_symbolic compute a valid symbolic factorization. | |
289 For the other cases below, no Symbolic object is created | |
290 (*Symbolic is (void *) NULL). | |
291 | |
292 UMFPACK_ERROR_n_nonpositive | |
293 | |
294 n is less than or equal to zero. | |
295 | |
296 UMFPACK_ERROR_invalid_matrix | |
297 | |
298 Number of entries in the matrix is negative, Ap [0] is nonzero, | |
299 a column has a negative number of entries, a row index is out of | |
300 bounds, or the columns of input matrix were jumbled (unsorted | |
301 columns or duplicate entries). | |
302 | |
303 UMFPACK_ERROR_out_of_memory | |
304 | |
305 Insufficient memory to perform the symbolic analysis. If the | |
306 analysis requires more than 2GB of memory and you are using | |
307 the 32-bit ("int") version of UMFPACK, then you are guaranteed | |
308 to run out of memory. Try using the 64-bit version of UMFPACK. | |
309 | |
310 UMFPACK_ERROR_argument_missing | |
311 | |
312 One or more required arguments is missing. | |
313 | |
314 UMFPACK_ERROR_internal_error | |
315 | |
316 Something very serious went wrong. This is a bug. | |
317 Please contact the author (davis@cise.ufl.edu). | |
318 | |
319 Info [UMFPACK_NROW]: the value of the input argument n_row. | |
320 | |
321 Info [UMFPACK_NCOL]: the value of the input argument n_col. | |
322 | |
323 Info [UMFPACK_NZ]: the number of entries in the input matrix | |
324 (Ap [n_col]). | |
325 | |
326 Info [UMFPACK_SIZE_OF_UNIT]: the number of bytes in a Unit, | |
327 for memory usage statistics below. | |
328 | |
329 Info [UMFPACK_SIZE_OF_INT]: the number of bytes in an int. | |
330 | |
331 Info [UMFPACK_SIZE_OF_LONG]: the number of bytes in a long. | |
332 | |
333 Info [UMFPACK_SIZE_OF_POINTER]: the number of bytes in a void * | |
334 pointer. | |
335 | |
336 Info [UMFPACK_SIZE_OF_ENTRY]: the number of bytes in a numerical entry. | |
337 | |
338 Info [UMFPACK_NDENSE_ROW]: number of "dense" rows in A. These rows are | |
339 ignored when the column pre-ordering is computed in COLAMD. They | |
340 are also treated differently during numeric factorization. If > 0, | |
341 then the matrix had to be re-analyzed by UMF_analyze, which does | |
342 not ignore these rows. | |
343 | |
344 Info [UMFPACK_NEMPTY_ROW]: number of "empty" rows in A, as determined | |
345 These are rows that either have no entries, or whose entries are | |
346 all in pivot columns of zero-Markowitz-cost pivots. | |
347 | |
348 Info [UMFPACK_NDENSE_COL]: number of "dense" columns in A. COLAMD | |
349 orders these columns are ordered last in the factorization, but | |
350 before "empty" columns. | |
351 | |
352 Info [UMFPACK_NEMPTY_COL]: number of "empty" columns in A. These are | |
353 columns that either have no entries, or whose entries are all in | |
354 pivot rows of zero-Markowitz-cost pivots. These columns are | |
355 ordered last in the factorization, to the right of "dense" columns. | |
356 | |
357 Info [UMFPACK_SYMBOLIC_DEFRAG]: number of garbage collections | |
358 performed during ordering and symbolic pre-analysis. | |
359 | |
360 Info [UMFPACK_SYMBOLIC_PEAK_MEMORY]: the amount of memory (in Units) | |
361 required for umfpack_*_symbolic to complete. This count includes | |
362 the size of the Symbolic object itself, which is also reported in | |
363 Info [UMFPACK_SYMBOLIC_SIZE]. | |
364 | |
365 Info [UMFPACK_SYMBOLIC_SIZE]: the final size of the Symbolic object (in | |
366 Units). This is fairly small, roughly 2*n to 13*n integers, | |
367 depending on the matrix. | |
368 | |
369 Info [UMFPACK_VARIABLE_INIT_ESTIMATE]: the Numeric object contains two | |
370 parts. The first is fixed in size (O (n_row+n_col)). The | |
371 second part holds the sparse LU factors and the contribution blocks | |
372 from factorized frontal matrices. This part changes in size during | |
373 factorization. Info [UMFPACK_VARIABLE_INIT_ESTIMATE] is the exact | |
374 size (in Units) required for this second variable-sized part in | |
375 order for the numerical factorization to start. | |
376 | |
377 Info [UMFPACK_VARIABLE_PEAK_ESTIMATE]: the estimated peak size (in | |
378 Units) of the variable-sized part of the Numeric object. This is | |
379 usually an upper bound, but that is not guaranteed. | |
380 | |
381 Info [UMFPACK_VARIABLE_FINAL_ESTIMATE]: the estimated final size (in | |
382 Units) of the variable-sized part of the Numeric object. This is | |
383 usually an upper bound, but that is not guaranteed. It holds just | |
384 the sparse LU factors. | |
385 | |
386 Info [UMFPACK_NUMERIC_SIZE_ESTIMATE]: an estimate of the final size (in | |
387 Units) of the entire Numeric object (both fixed-size and variable- | |
388 sized parts), which holds the LU factorization (including the L, U, | |
389 P and Q matrices). | |
390 | |
391 Info [UMFPACK_PEAK_MEMORY_ESTIMATE]: an estimate of the total amount of | |
392 memory (in Units) required by umfpack_*_symbolic and | |
393 umfpack_*_numeric to perform both the symbolic and numeric | |
394 factorization. This is the larger of the amount of memory needed | |
395 in umfpack_*_numeric itself, and the amount of memory needed in | |
396 umfpack_*_symbolic (Info [UMFPACK_SYMBOLIC_PEAK_MEMORY]). The | |
397 count includes the size of both the Symbolic and Numeric objects | |
398 themselves. It can be a very loose upper bound, particularly when | |
399 the symmetric or 2-by-2 strategies are used. | |
400 | |
401 Info [UMFPACK_FLOPS_ESTIMATE]: an estimate of the total floating-point | |
402 operations required to factorize the matrix. This is a "true" | |
403 theoretical estimate of the number of flops that would be performed | |
404 by a flop-parsimonious sparse LU algorithm. It assumes that no | |
405 extra flops are performed except for what is strictly required to | |
406 compute the LU factorization. It ignores, for example, the flops | |
407 performed by umfpack_di_numeric to add contribution blocks of | |
408 frontal matrices together. If L and U are the upper bound on the | |
409 pattern of the factors, then this flop count estimate can be | |
410 represented in MATLAB (for real matrices, not complex) as: | |
411 | |
412 Lnz = full (sum (spones (L))) - 1 ; % nz in each col of L | |
413 Unz = full (sum (spones (U')))' - 1 ; % nz in each row of U | |
414 flops = 2*Lnz*Unz + sum (Lnz) ; | |
415 | |
416 The actual "true flop" count found by umfpack_*_numeric will be | |
417 less than this estimate. | |
418 | |
419 For the real version, only (+ - * /) are counted. For the complex | |
420 version, the following counts are used: | |
421 | |
422 operation flops | |
423 c = 1/b 6 | |
424 c = a*b 6 | |
425 c -= a*b 8 | |
426 | |
427 Info [UMFPACK_LNZ_ESTIMATE]: an estimate of the number of nonzeros in | |
428 L, including the diagonal. Since L is unit-diagonal, the diagonal | |
429 of L is not stored. This estimate is a strict upper bound on the | |
430 actual nonzeros in L to be computed by umfpack_*_numeric. | |
431 | |
432 Info [UMFPACK_UNZ_ESTIMATE]: an estimate of the number of nonzeros in | |
433 U, including the diagonal. This estimate is a strict upper bound on | |
434 the actual nonzeros in U to be computed by umfpack_*_numeric. | |
435 | |
436 Info [UMFPACK_MAX_FRONT_SIZE_ESTIMATE]: estimate of the size of the | |
437 largest frontal matrix (# of entries), for arbitrary partial | |
438 pivoting during numerical factorization. | |
439 | |
440 Info [UMFPACK_SYMBOLIC_TIME]: The CPU time taken, in seconds. | |
441 | |
442 Info [UMFPACK_SYMBOLIC_WALLTIME]: The wallclock time taken, in seconds. | |
443 | |
444 Info [UMFPACK_STRATEGY_USED]: The ordering strategy used: | |
445 UMFPACK_STRATEGY_SYMMETRIC, UMFPACK_STRATEGY_UNSYMMETRIC, or | |
446 UMFPACK_STRATEGY_2BY2. | |
447 | |
448 Info [UMFPACK_ORDERING_USED]: The ordering method used: | |
449 UMFPACK_ORDERING_COLAMD or UMFPACK_ORDERING_AMD. It can be | |
450 UMFPACK_ORDERING_GIVEN for umfpack_*_qsymbolic. | |
451 | |
452 Info [UMFPACK_QFIXED]: 1 if the column pre-ordering will be refined | |
453 during numerical factorization, 0 if not. | |
454 | |
455 Info [UMFPACK_DIAG_PREFERED]: 1 if diagonal pivoting will be attempted, | |
456 0 if not. | |
457 | |
458 Info [UMFPACK_COL_SINGLETONS]: the matrix A is analyzed by first | |
459 eliminating all pivots with zero Markowitz cost. This count is the | |
460 number of these pivots with exactly one nonzero in their pivot | |
461 column. | |
462 | |
463 Info [UMFPACK_ROW_SINGLETONS]: the number of zero-Markowitz-cost | |
464 pivots with exactly one nonzero in their pivot row. | |
465 | |
466 Info [UMFPACK_PATTERN_SYMMETRY]: the symmetry of the pattern of S. | |
467 | |
468 Info [UMFPACK_NZ_A_PLUS_AT]: the number of off-diagonal entries in S+S'. | |
469 | |
470 Info [UMFPACK_NZDIAG]: the number of entries on the diagonal of S. | |
471 | |
472 Info [UMFPACK_N2]: if S is square, and nempty_row = nempty_col, this | |
473 is equal to n_row - n1 - nempty_row. | |
474 | |
475 Info [UMFPACK_S_SYMMETRIC]: 1 if S is square and its diagonal has been | |
476 preserved, 0 otherwise. | |
477 | |
478 | |
479 Info [UMFPACK_MAX_FRONT_NROWS_ESTIMATE]: estimate of the max number of | |
480 rows in any frontal matrix, for arbitrary partial pivoting. | |
481 | |
482 Info [UMFPACK_MAX_FRONT_NCOLS_ESTIMATE]: estimate of the max number of | |
483 columns in any frontal matrix, for arbitrary partial pivoting. | |
484 | |
485 ------------------------------------------------------------------------ | |
486 The next four statistics are computed only if AMD is used: | |
487 ------------------------------------------------------------------------ | |
488 | |
489 Info [UMFPACK_SYMMETRIC_LUNZ]: The number of nonzeros in L and U, | |
490 assuming no pivoting during numerical factorization, and assuming a | |
491 zero-free diagonal of U. Excludes the entries on the diagonal of | |
492 L. If the matrix has a purely symmetric nonzero pattern, this is | |
493 often a lower bound on the nonzeros in the actual L and U computed | |
494 in the numerical factorization, for matrices that fit the criteria | |
495 for the "symmetric" strategy. | |
496 | |
497 Info [UMFPACK_SYMMETRIC_FLOPS]: The floating-point operation count in | |
498 the numerical factorization phase, assuming no pivoting. If the | |
499 pattern of the matrix is symmetric, this is normally a lower bound | |
500 on the floating-point operation count in the actual numerical | |
501 factorization, for matrices that fit the criteria for the symmetric | |
502 or 2-by-2 strategies | |
503 | |
504 Info [UMFPACK_SYMMETRIC_NDENSE]: The number of "dense" rows/columns of | |
505 S+S' that were ignored during the AMD ordering. These are placed | |
506 last in the output order. If > 0, then the | |
507 Info [UMFPACK_SYMMETRIC_*] statistics, above are rough upper bounds. | |
508 | |
509 Info [UMFPACK_SYMMETRIC_DMAX]: The maximum number of nonzeros in any | |
510 column of L, if no pivoting is performed during numerical | |
511 factorization. Excludes the part of the LU factorization for | |
512 pivots with zero Markowitz cost. | |
513 | |
514 ------------------------------------------------------------------------ | |
515 The following statistics are computed only if the 2-by-2 strategy is | |
516 used or attempted: | |
517 ------------------------------------------------------------------------ | |
518 | |
519 Info [UMFPACK_2BY2_NWEAK]: the number of small diagonal entries in S. | |
520 | |
521 Info [UMFPACK_2BY2_UNMATCHED]: the number of small diagonal entries | |
522 in P2*S. | |
523 | |
524 Info [UMFPACK_2BY2_PATTERN_SYMMETRY]: the symmetry of P2*S. | |
525 | |
526 Info [UMFPACK_2BY2_NZ_PA_PLUS_AT]: the number of off-diagonal entries | |
527 in (P2*S)+(P2*S)'. | |
528 | |
529 Info [UMFPACK_2BY2_NZDIAG]: the number of nonzero entries on the | |
530 diagonal of P2*S. | |
531 | |
532 | |
533 At the start of umfpack_*_symbolic, all of Info is set of -1, and then | |
534 after that only the above listed Info [...] entries are accessed. | |
535 Future versions might modify different parts of Info. | |
536 */ |