|
5164
|
1 /* ========================================================================== */ |
|
|
2 /* === umfpack_numeric ====================================================== */ |
|
|
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_numeric |
|
|
12 ( |
|
|
13 const int Ap [ ], |
|
|
14 const int Ai [ ], |
|
|
15 const double Ax [ ], |
|
|
16 void *Symbolic, |
|
|
17 void **Numeric, |
|
|
18 const double Control [UMFPACK_CONTROL], |
|
|
19 double Info [UMFPACK_INFO] |
|
|
20 ) ; |
|
|
21 |
|
|
22 long umfpack_dl_numeric |
|
|
23 ( |
|
|
24 const long Ap [ ], |
|
|
25 const long Ai [ ], |
|
|
26 const double Ax [ ], |
|
|
27 void *Symbolic, |
|
|
28 void **Numeric, |
|
|
29 const double Control [UMFPACK_CONTROL], |
|
|
30 double Info [UMFPACK_INFO] |
|
|
31 ) ; |
|
|
32 |
|
|
33 int umfpack_zi_numeric |
|
|
34 ( |
|
|
35 const int Ap [ ], |
|
|
36 const int Ai [ ], |
|
|
37 const double Ax [ ], const double Az [ ], |
|
|
38 void *Symbolic, |
|
|
39 void **Numeric, |
|
|
40 const double Control [UMFPACK_CONTROL], |
|
|
41 double Info [UMFPACK_INFO] |
|
|
42 ) ; |
|
|
43 |
|
|
44 long umfpack_zl_numeric |
|
|
45 ( |
|
|
46 const long Ap [ ], |
|
|
47 const long Ai [ ], |
|
|
48 const double Ax [ ], const double Az [ ], |
|
|
49 void *Symbolic, |
|
|
50 void **Numeric, |
|
|
51 const double Control [UMFPACK_CONTROL], |
|
|
52 double Info [UMFPACK_INFO] |
|
|
53 ) ; |
|
|
54 |
|
|
55 /* |
|
|
56 double int Syntax: |
|
|
57 |
|
|
58 #include "umfpack.h" |
|
|
59 void *Symbolic, *Numeric ; |
|
|
60 int *Ap, *Ai, status ; |
|
|
61 double *Ax, Control [UMFPACK_CONTROL], Info [UMFPACK_INFO] ; |
|
|
62 status = umfpack_di_numeric (Ap, Ai, Ax, Symbolic, &Numeric, Control, Info); |
|
|
63 |
|
|
64 double long Syntax: |
|
|
65 |
|
|
66 #include "umfpack.h" |
|
|
67 void *Symbolic, *Numeric ; |
|
|
68 long *Ap, *Ai, status ; |
|
|
69 double *Ax, Control [UMFPACK_CONTROL], Info [UMFPACK_INFO] ; |
|
|
70 status = umfpack_dl_numeric (Ap, Ai, Ax, Symbolic, &Numeric, Control, Info); |
|
|
71 |
|
|
72 complex int Syntax: |
|
|
73 |
|
|
74 #include "umfpack.h" |
|
|
75 void *Symbolic, *Numeric ; |
|
|
76 int *Ap, *Ai, status ; |
|
|
77 double *Ax, *Az, Control [UMFPACK_CONTROL], Info [UMFPACK_INFO] ; |
|
|
78 status = umfpack_zi_numeric (Ap, Ai, Ax, Az, Symbolic, &Numeric, |
|
|
79 Control, Info) ; |
|
|
80 |
|
|
81 complex long Syntax: |
|
|
82 |
|
|
83 #include "umfpack.h" |
|
|
84 void *Symbolic, *Numeric ; |
|
|
85 long *Ap, *Ai, status ; |
|
|
86 double *Ax, *Az, Control [UMFPACK_CONTROL], Info [UMFPACK_INFO] ; |
|
|
87 status = umfpack_zl_numeric (Ap, Ai, Ax, Az, Symbolic, &Numeric, |
|
|
88 Control, Info) ; |
|
|
89 |
|
|
90 packed complex Syntax: |
|
|
91 |
|
|
92 Same as above, except that Az is NULL. |
|
|
93 |
|
|
94 Purpose: |
|
|
95 |
|
|
96 Given a sparse matrix A in column-oriented form, and a symbolic analysis |
|
|
97 computed by umfpack_*_*symbolic, the umfpack_*_numeric routine performs the |
|
|
98 numerical factorization, PAQ=LU, PRAQ=LU, or P(R\A)Q=LU, where P and Q are |
|
|
99 permutation matrices (represented as permutation vectors), R is the row |
|
|
100 scaling, L is unit-lower triangular, and U is upper triangular. This is |
|
|
101 required before the system Ax=b (or other related linear systems) can be |
|
|
102 solved. umfpack_*_numeric can be called multiple times for each call to |
|
|
103 umfpack_*_*symbolic, to factorize a sequence of matrices with identical |
|
|
104 nonzero pattern. Simply compute the Symbolic object once, with |
|
|
105 umfpack_*_*symbolic, and reuse it for subsequent matrices. This routine |
|
|
106 safely detects if the pattern changes, and sets an appropriate error code. |
|
|
107 |
|
|
108 Returns: |
|
|
109 |
|
|
110 The status code is returned. See Info [UMFPACK_STATUS], below. |
|
|
111 |
|
|
112 Arguments: |
|
|
113 |
|
|
114 Int Ap [n_col+1] ; Input argument, not modified. |
|
|
115 |
|
|
116 This must be identical to the Ap array passed to umfpack_*_*symbolic. |
|
|
117 The value of n_col is what was passed to umfpack_*_*symbolic (this is |
|
|
118 held in the Symbolic object). |
|
|
119 |
|
|
120 Int Ai [nz] ; Input argument, not modified, of size nz = Ap [n_col]. |
|
|
121 |
|
|
122 This must be identical to the Ai array passed to umfpack_*_*symbolic. |
|
|
123 |
|
|
124 double Ax [nz] ; Input argument, not modified, of size nz = Ap [n_col]. |
|
|
125 Size 2*nz for packed complex case. |
|
|
126 |
|
|
127 The numerical values of the sparse matrix A. The nonzero pattern (row |
|
|
128 indices) for column j is stored in Ai [(Ap [j]) ... (Ap [j+1]-1)], and |
|
|
129 the corresponding numerical values are stored in |
|
|
130 Ax [(Ap [j]) ... (Ap [j+1]-1)]. |
|
|
131 |
|
|
132 double Az [nz] ; Input argument, not modified, for complex versions. |
|
|
133 |
|
|
134 For the complex versions, this holds the imaginary part of A. The |
|
|
135 imaginary part of column j is held in Az [(Ap [j]) ... (Ap [j+1]-1)]. |
|
|
136 |
|
|
137 If Az is NULL, then both real |
|
|
138 and imaginary parts are contained in Ax[0..2*nz-1], with Ax[2*k] |
|
|
139 and Ax[2*k+1] being the real and imaginary part of the kth entry. |
|
|
140 |
|
|
141 void *Symbolic ; Input argument, not modified. |
|
|
142 |
|
|
143 The Symbolic object, which holds the symbolic factorization computed by |
|
|
144 umfpack_*_*symbolic. The Symbolic object is not modified by |
|
|
145 umfpack_*_numeric. |
|
|
146 |
|
|
147 void **Numeric ; Output argument. |
|
|
148 |
|
|
149 **Numeric is the address of a (void *) pointer variable in the user's |
|
|
150 calling routine (see Syntax, above). On input, the contents of this |
|
|
151 variable are not defined. On output, this variable holds a (void *) |
|
|
152 pointer to the Numeric object (if successful), or (void *) NULL if |
|
|
153 a failure occurred. |
|
|
154 |
|
|
155 double Control [UMFPACK_CONTROL] ; Input argument, not modified. |
|
|
156 |
|
|
157 If a (double *) NULL pointer is passed, then the default control |
|
|
158 settings are used. Otherwise, the settings are determined from the |
|
|
159 Control array. See umfpack_*_defaults on how to fill the Control |
|
|
160 array with the default settings. If Control contains NaN's, the |
|
|
161 defaults are used. The following Control parameters are used: |
|
|
162 |
|
|
163 Control [UMFPACK_PIVOT_TOLERANCE]: relative pivot tolerance for |
|
|
164 threshold partial pivoting with row interchanges. In any given |
|
|
165 column, an entry is numerically acceptable if its absolute value is |
|
|
166 greater than or equal to Control [UMFPACK_PIVOT_TOLERANCE] times |
|
|
167 the largest absolute value in the column. A value of 1.0 gives true |
|
|
168 partial pivoting. If less than or equal to zero, then any nonzero |
|
|
169 entry is numerically acceptable as a pivot. Default: 0.1. |
|
|
170 |
|
|
171 Smaller values tend to lead to sparser LU factors, but the solution |
|
|
172 to the linear system can become inaccurate. Larger values can lead |
|
|
173 to a more accurate solution (but not always), and usually an |
|
|
174 increase in the total work. |
|
|
175 |
|
|
176 For complex matrices, a cheap approximate of the absolute value |
|
|
177 is used for the threshold partial pivoting test (|a_real| + |a_imag| |
|
|
178 instead of the more expensive-to-compute exact absolute value |
|
|
179 sqrt (a_real^2 + a_imag^2)). |
|
|
180 |
|
|
181 Control [UMFPACK_SYM_PIVOT_TOLERANCE]: |
|
|
182 If diagonal pivoting is attempted (the symmetric or symmetric-2by2 |
|
|
183 strategies are used) then this parameter is used to control when the |
|
|
184 diagonal entry is selected in a given pivot column. The absolute |
|
|
185 value of the entry must be >= Control [UMFPACK_SYM_PIVOT_TOLERANCE] |
|
|
186 times the largest absolute value in the column. A value of zero |
|
|
187 will ensure that no off-diagonal pivoting is performed, except that |
|
|
188 zero diagonal entries are not selected if there are any off-diagonal |
|
|
189 nonzero entries. |
|
|
190 |
|
|
191 If an off-diagonal pivot is selected, an attempt is made to restore |
|
|
192 symmetry later on. Suppose A (i,j) is selected, where i != j. |
|
|
193 If column i has not yet been selected as a pivot column, then |
|
|
194 the entry A (j,i) is redefined as a "diagonal" entry, except that |
|
|
195 the tighter tolerance (Control [UMFPACK_PIVOT_TOLERANCE]) is |
|
|
196 applied. This strategy has an effect similar to 2-by-2 pivoting |
|
|
197 for symmetric indefinite matrices. If a 2-by-2 block pivot with |
|
|
198 nonzero structure |
|
|
199 |
|
|
200 i j |
|
|
201 i: 0 x |
|
|
202 j: x 0 |
|
|
203 |
|
|
204 is selected in a symmetric indefinite factorization method, the |
|
|
205 2-by-2 block is inverted and a rank-2 update is applied. In |
|
|
206 UMFPACK, this 2-by-2 block would be reordered as |
|
|
207 |
|
|
208 j i |
|
|
209 i: x 0 |
|
|
210 j: 0 x |
|
|
211 |
|
|
212 In both cases, the symmetry of the Schur complement is preserved. |
|
|
213 |
|
|
214 Control [UMFPACK_SCALE]: Note that the user's input matrix is |
|
|
215 never modified, only an internal copy is scaled. |
|
|
216 |
|
|
217 There are three valid settings for this parameter. If any other |
|
|
218 value is provided, the default is used. |
|
|
219 |
|
|
220 UMFPACK_SCALE_NONE: no scaling is performed. |
|
|
221 |
|
|
222 UMFPACK_SCALE_SUM: each row of the input matrix A is divided by |
|
|
223 the sum of the absolute values of the entries in that row. |
|
|
224 The scaled matrix has an infinity norm of 1. |
|
|
225 |
|
|
226 UMFPACK_SCALE_MAX: each row of the input matrix A is divided by |
|
|
227 the maximum the absolute values of the entries in that row. |
|
|
228 In the scaled matrix the largest entry in each row has |
|
|
229 a magnitude exactly equal to 1. |
|
|
230 |
|
|
231 Note that for complex matrices, a cheap approximate absolute value |
|
|
232 is used, |a_real| + |a_imag|, instead of the exact absolute value |
|
|
233 sqrt ((a_real)^2 + (a_imag)^2). |
|
|
234 |
|
|
235 Scaling is very important for the "symmetric" strategy when |
|
|
236 diagonal pivoting is attempted. It also improves the performance |
|
|
237 of the "unsymmetric" strategy. |
|
|
238 |
|
|
239 Default: UMFPACK_SCALE_SUM. |
|
|
240 |
|
|
241 Control [UMFPACK_ALLOC_INIT]: |
|
|
242 |
|
|
243 When umfpack_*_numeric starts, it allocates memory for the Numeric |
|
|
244 object. Part of this is of fixed size (approximately n double's + |
|
|
245 12*n integers). The remainder is of variable size, which grows to |
|
|
246 hold the LU factors and the frontal matrices created during |
|
|
247 factorization. A estimate of the upper bound is computed by |
|
|
248 umfpack_*_*symbolic, and returned by umfpack_*_*symbolic in |
|
|
249 Info [UMFPACK_VARIABLE_PEAK_ESTIMATE] (in Units). |
|
|
250 |
|
|
251 If Control [UMFPACK_ALLOC_INIT] is >= 0, umfpack_*_numeric initially |
|
|
252 allocates space for the variable-sized part equal to this estimate |
|
|
253 times Control [UMFPACK_ALLOC_INIT]. Typically, for matrices for |
|
|
254 which the "unsymmetric" strategy applies, umfpack_*_numeric needs |
|
|
255 only about half the estimated memory space, so a setting of 0.5 or |
|
|
256 0.6 often provides enough memory for umfpack_*_numeric to factorize |
|
|
257 the matrix with no subsequent increases in the size of this block. |
|
|
258 |
|
|
259 If the matrix is ordered via AMD, then this non-negative parameter |
|
|
260 is ignored. The initial allocation ratio computed automatically, |
|
|
261 as 1.2 * (nz + Info [UMFPACK_SYMMETRIC_LUNZ]) / |
|
|
262 (Info [UMFPACK_LNZ_ESTIMATE] + Info [UMFPACK_UNZ_ESTIMATE] - |
|
|
263 min (n_row, n_col)). |
|
|
264 |
|
|
265 If Control [UMFPACK_ALLOC_INIT] is negative, then umfpack_*_numeric |
|
|
266 allocates a space with initial size (in Units) equal to |
|
|
267 (-Control [UMFPACK_ALLOC_INIT]). |
|
|
268 |
|
|
269 Regardless of the value of this parameter, a space equal to or |
|
|
270 greater than the the bare minimum amount of memory needed to start |
|
|
271 the factorization is always initially allocated. The bare initial |
|
|
272 memory required is returned by umfpack_*_*symbolic in |
|
|
273 Info [UMFPACK_VARIABLE_INIT_ESTIMATE] (an exact value, not an |
|
|
274 estimate). |
|
|
275 |
|
|
276 If the variable-size part of the Numeric object is found to be too |
|
|
277 small sometime after numerical factorization has started, the memory |
|
|
278 is increased in size by a factor of 1.2. If this fails, the |
|
|
279 request is reduced by a factor of 0.95 until it succeeds, or until |
|
|
280 it determines that no increase in size is possible. Garbage |
|
|
281 collection then occurs. |
|
|
282 |
|
|
283 The strategy of attempting to "malloc" a working space, and |
|
|
284 re-trying with a smaller space, may not work under MATLAB, since |
|
|
285 mxMalloc aborts the mexFunction if it fails. The built-in umfpack |
|
|
286 routine in MATLAB 6.5 uses utMalloc instead, which |
|
|
287 avoids this problem. As a mexFunction, utMalloc is used unless |
|
|
288 -DNUTIL is defined at compile time. The utMalloc routine, and |
|
|
289 utFree and utRealloc, are not documented. If the mexFunction |
|
|
290 doesn't work, then compile it with -DNUTIL instead. |
|
|
291 |
|
|
292 If you are using the umfpack mexFunction, decrease the magnitude of |
|
|
293 Control [UMFPACK_ALLOC_INIT] if you run out of memory in MATLAB. |
|
|
294 |
|
|
295 Default initial allocation size: 0.7. Thus, with the default |
|
|
296 control settings and the "unsymmetric" strategy, the upper-bound is |
|
|
297 reached after two reallocations (0.7 * 1.2 * 1.2 = 1.008). |
|
|
298 |
|
|
299 Changing this parameter has little effect on fill-in or operation |
|
|
300 count. It has a small impact on run-time (the extra time required |
|
|
301 to do the garbage collection and memory reallocation). |
|
|
302 |
|
|
303 Control [UMFPACK_FRONT_ALLOC_INIT]: |
|
|
304 |
|
|
305 When UMFPACK starts the factorization of each "chain" of frontal |
|
|
306 matrices, it allocates a working array to hold the frontal matrices |
|
|
307 as they are factorized. The symbolic factorization computes the |
|
|
308 size of the largest possible frontal matrix that could occur during |
|
|
309 the factorization of each chain. |
|
|
310 |
|
|
311 If Control [UMFPACK_FRONT_ALLOC_INIT] is >= 0, the following |
|
|
312 strategy is used. If the AMD ordering was used, this non-negative |
|
|
313 parameter is ignored. A front of size (d+2)*(d+2) is allocated, |
|
|
314 where d = Info [UMFPACK_SYMMETRIC_DMAX]. Otherwise, a front of |
|
|
315 size Control [UMFPACK_FRONT_ALLOC_INIT] times the largest front |
|
|
316 possible for this chain is allocated. |
|
|
317 |
|
|
318 If Control [UMFPACK_FRONT_ALLOC_INIT] is negative, then a front of |
|
|
319 size (-Control [UMFPACK_FRONT_ALLOC_INIT]) is allocated (where the |
|
|
320 size is in terms of the number of numerical entries). This is done |
|
|
321 regardless of the ordering method or ordering strategy used. |
|
|
322 |
|
|
323 Default: 0.5. |
|
|
324 |
|
|
325 Control [UMFPACK_DROPTOL]: |
|
|
326 |
|
|
327 Entries in L and U with absolute value less than or equal to the |
|
|
328 drop tolerance are removed from the data structures (unless leaving |
|
|
329 them there reduces memory usage by reducing the space required |
|
|
330 for the nonzero pattern of L and U). |
|
|
331 |
|
|
332 Default: 0.0. |
|
|
333 |
|
|
334 double Info [UMFPACK_INFO] ; Output argument. |
|
|
335 |
|
|
336 Contains statistics about the numeric factorization. If a |
|
|
337 (double *) NULL pointer is passed, then no statistics are returned in |
|
|
338 Info (this is not an error condition). The following statistics are |
|
|
339 computed in umfpack_*_numeric: |
|
|
340 |
|
|
341 Info [UMFPACK_STATUS]: status code. This is also the return value, |
|
|
342 whether or not Info is present. |
|
|
343 |
|
|
344 UMFPACK_OK |
|
|
345 |
|
|
346 Numeric factorization was successful. umfpack_*_numeric |
|
|
347 computed a valid numeric factorization. |
|
|
348 |
|
|
349 UMFPACK_WARNING_singular_matrix |
|
|
350 |
|
|
351 Numeric factorization was successful, but the matrix is |
|
|
352 singular. umfpack_*_numeric computed a valid numeric |
|
|
353 factorization, but you will get a divide by zero in |
|
|
354 umfpack_*_*solve. For the other cases below, no Numeric object |
|
|
355 is created (*Numeric is (void *) NULL). |
|
|
356 |
|
|
357 UMFPACK_ERROR_out_of_memory |
|
|
358 |
|
|
359 Insufficient memory to complete the numeric factorization. |
|
|
360 |
|
|
361 UMFPACK_ERROR_argument_missing |
|
|
362 |
|
|
363 One or more required arguments are missing. |
|
|
364 |
|
|
365 UMFPACK_ERROR_invalid_Symbolic_object |
|
|
366 |
|
|
367 Symbolic object provided as input is invalid. |
|
|
368 |
|
|
369 UMFPACK_ERROR_different_pattern |
|
|
370 |
|
|
371 The pattern (Ap and/or Ai) has changed since the call to |
|
|
372 umfpack_*_*symbolic which produced the Symbolic object. |
|
|
373 |
|
|
374 Info [UMFPACK_NROW]: the value of n_row stored in the Symbolic object. |
|
|
375 |
|
|
376 Info [UMFPACK_NCOL]: the value of n_col stored in the Symbolic object. |
|
|
377 |
|
|
378 Info [UMFPACK_NZ]: the number of entries in the input matrix. |
|
|
379 This value is obtained from the Symbolic object. |
|
|
380 |
|
|
381 Info [UMFPACK_SIZE_OF_UNIT]: the number of bytes in a Unit, for memory |
|
|
382 usage statistics below. |
|
|
383 |
|
|
384 Info [UMFPACK_VARIABLE_INIT]: the initial size (in Units) of the |
|
|
385 variable-sized part of the Numeric object. If this differs from |
|
|
386 Info [UMFPACK_VARIABLE_INIT_ESTIMATE], then the pattern (Ap and/or |
|
|
387 Ai) has changed since the last call to umfpack_*_*symbolic, which is |
|
|
388 an error condition. |
|
|
389 |
|
|
390 Info [UMFPACK_VARIABLE_PEAK]: the peak size (in Units) of the |
|
|
391 variable-sized part of the Numeric object. This size is the amount |
|
|
392 of space actually used inside the block of memory, not the space |
|
|
393 allocated via UMF_malloc. You can reduce UMFPACK's memory |
|
|
394 requirements by setting Control [UMFPACK_ALLOC_INIT] to the ratio |
|
|
395 Info [UMFPACK_VARIABLE_PEAK] / Info[UMFPACK_VARIABLE_PEAK_ESTIMATE]. |
|
|
396 This will ensure that no memory reallocations occur (you may want to |
|
|
397 add 0.001 to make sure that integer roundoff does not lead to a |
|
|
398 memory size that is 1 Unit too small; otherwise, garbage collection |
|
|
399 and reallocation will occur). |
|
|
400 |
|
|
401 Info [UMFPACK_VARIABLE_FINAL]: the final size (in Units) of the |
|
|
402 variable-sized part of the Numeric object. It holds just the |
|
|
403 sparse LU factors. |
|
|
404 |
|
|
405 Info [UMFPACK_NUMERIC_SIZE]: the actual final size (in Units) of the |
|
|
406 entire Numeric object, including the final size of the variable |
|
|
407 part of the object. Info [UMFPACK_NUMERIC_SIZE_ESTIMATE], |
|
|
408 an estimate, was computed by umfpack_*_*symbolic. The estimate is |
|
|
409 normally an upper bound on the actual final size, but this is not |
|
|
410 guaranteed. |
|
|
411 |
|
|
412 Info [UMFPACK_PEAK_MEMORY]: the actual peak memory usage (in Units) of |
|
|
413 both umfpack_*_*symbolic and umfpack_*_numeric. An estimate, |
|
|
414 Info [UMFPACK_PEAK_MEMORY_ESTIMATE], was computed by |
|
|
415 umfpack_*_*symbolic. The estimate is normally an upper bound on the |
|
|
416 actual peak usage, but this is not guaranteed. With testing on |
|
|
417 hundreds of matrix arising in real applications, I have never |
|
|
418 observed a matrix where this estimate or the Numeric size estimate |
|
|
419 was less than the actual result, but this is theoretically possible. |
|
|
420 Please send me one if you find such a matrix. |
|
|
421 |
|
|
422 Info [UMFPACK_FLOPS]: the actual count of the (useful) floating-point |
|
|
423 operations performed. An estimate, Info [UMFPACK_FLOPS_ESTIMATE], |
|
|
424 was computed by umfpack_*_*symbolic. The estimate is guaranteed to |
|
|
425 be an upper bound on this flop count. The flop count excludes |
|
|
426 "useless" flops on zero values, flops performed during the pivot |
|
|
427 search (for tentative updates and assembly of candidate columns), |
|
|
428 and flops performed to add frontal matrices together. |
|
|
429 |
|
|
430 For the real version, only (+ - * /) are counted. For the complex |
|
|
431 version, the following counts are used: |
|
|
432 |
|
|
433 operation flops |
|
|
434 c = 1/b 6 |
|
|
435 c = a*b 6 |
|
|
436 c -= a*b 8 |
|
|
437 |
|
|
438 Info [UMFPACK_LNZ]: the actual nonzero entries in final factor L, |
|
|
439 including the diagonal. This excludes any zero entries in L, |
|
|
440 although some of these are stored in the Numeric object. The |
|
|
441 Info [UMFPACK_LU_ENTRIES] statistic does account for all |
|
|
442 explicitly stored zeros, however. Info [UMFPACK_LNZ_ESTIMATE], |
|
|
443 an estimate, was computed by umfpack_*_*symbolic. The estimate is |
|
|
444 guaranteed to be an upper bound on Info [UMFPACK_LNZ]. |
|
|
445 |
|
|
446 Info [UMFPACK_UNZ]: the actual nonzero entries in final factor U, |
|
|
447 including the diagonal. This excludes any zero entries in U, |
|
|
448 although some of these are stored in the Numeric object. The |
|
|
449 Info [UMFPACK_LU_ENTRIES] statistic does account for all |
|
|
450 explicitly stored zeros, however. Info [UMFPACK_UNZ_ESTIMATE], |
|
|
451 an estimate, was computed by umfpack_*_*symbolic. The estimate is |
|
|
452 guaranteed to be an upper bound on Info [UMFPACK_UNZ]. |
|
|
453 |
|
|
454 Info [UMFPACK_NUMERIC_DEFRAG]: The number of garbage collections |
|
|
455 performed during umfpack_*_numeric, to compact the contents of the |
|
|
456 variable-sized workspace used by umfpack_*_numeric. No estimate was |
|
|
457 computed by umfpack_*_*symbolic. In the current version of UMFPACK, |
|
|
458 garbage collection is performed and then the memory is reallocated, |
|
|
459 so this statistic is the same as Info [UMFPACK_NUMERIC_REALLOC], |
|
|
460 below. It may differ in future releases. |
|
|
461 |
|
|
462 Info [UMFPACK_NUMERIC_REALLOC]: The number of times that the Numeric |
|
|
463 object was increased in size from its initial size. A rough upper |
|
|
464 bound on the peak size of the Numeric object was computed by |
|
|
465 umfpack_*_*symbolic, so reallocations should be rare. However, if |
|
|
466 umfpack_*_numeric is unable to allocate that much storage, it |
|
|
467 reduces its request until either the allocation succeeds, or until |
|
|
468 it gets too small to do anything with. If the memory that it |
|
|
469 finally got was small, but usable, then the reallocation count |
|
|
470 could be high. No estimate of this count was computed by |
|
|
471 umfpack_*_*symbolic. |
|
|
472 |
|
|
473 Info [UMFPACK_NUMERIC_COSTLY_REALLOC]: The number of times that the |
|
|
474 system realloc library routine (or mxRealloc for the mexFunction) |
|
|
475 had to move the workspace. Realloc can sometimes increase the size |
|
|
476 of a block of memory without moving it, which is much faster. This |
|
|
477 statistic will always be <= Info [UMFPACK_NUMERIC_REALLOC]. If your |
|
|
478 memory space is fragmented, then the number of "costly" realloc's |
|
|
479 will be equal to Info [UMFPACK_NUMERIC_REALLOC]. |
|
|
480 |
|
|
481 Info [UMFPACK_COMPRESSED_PATTERN]: The number of integers used to |
|
|
482 represent the pattern of L and U. |
|
|
483 |
|
|
484 Info [UMFPACK_LU_ENTRIES]: The total number of numerical values that |
|
|
485 are stored for the LU factors. Some of the values may be explicitly |
|
|
486 zero in order to save space (allowing for a smaller compressed |
|
|
487 pattern). |
|
|
488 |
|
|
489 Info [UMFPACK_NUMERIC_TIME]: The CPU time taken, in seconds. |
|
|
490 |
|
|
491 Info [UMFPACK_RCOND]: A rough estimate of the condition number, equal |
|
|
492 to min (abs (diag (U))) / max (abs (diag (U))), or zero if the |
|
|
493 diagonal of U is all zero. |
|
|
494 |
|
|
495 Info [UMFPACK_UDIAG_NZ]: The number of numerically nonzero values on |
|
|
496 the diagonal of U. |
|
|
497 |
|
|
498 Info [UMFPACK_UMIN]: the smallest absolute value on the diagonal of U. |
|
|
499 |
|
|
500 Info [UMFPACK_UMAX]: the smallest absolute value on the diagonal of U. |
|
|
501 |
|
|
502 Info [UMFPACK_MAX_FRONT_SIZE]: the size of the |
|
|
503 largest frontal matrix (number of entries). |
|
|
504 |
|
|
505 Info [UMFPACK_NUMERIC_WALLTIME]: The wallclock time taken, in seconds. |
|
|
506 |
|
|
507 Info [UMFPACK_MAX_FRONT_NROWS]: the max number of |
|
|
508 rows in any frontal matrix. |
|
|
509 |
|
|
510 Info [UMFPACK_MAX_FRONT_NCOLS]: the max number of |
|
|
511 columns in any frontal matrix. |
|
|
512 |
|
|
513 Info [UMFPACK_WAS_SCALED]: the scaling used, either UMFPACK_SCALE_NONE, |
|
|
514 UMFPACK_SCALE_SUM, or UMFPACK_SCALE_MAX. |
|
|
515 |
|
|
516 Info [UMFPACK_RSMIN]: if scaling is performed, the smallest scale factor |
|
|
517 for any row (either the smallest sum of absolute entries, or the |
|
|
518 smallest maximum of absolute entries). |
|
|
519 |
|
|
520 Info [UMFPACK_RSMAX]: if scaling is performed, the largest scale factor |
|
|
521 for any row (either the largest sum of absolute entries, or the |
|
|
522 largest maximum of absolute entries). |
|
|
523 |
|
|
524 Info [UMFPACK_ALLOC_INIT_USED]: the initial allocation parameter used. |
|
|
525 |
|
|
526 Info [UMFPACK_FORCED_UPDATES]: the number of BLAS-3 updates to the |
|
|
527 frontal matrices that were required because the frontal matrix |
|
|
528 grew larger than its current working array. |
|
|
529 |
|
|
530 Info [UMFPACK_NOFF_DIAG]: number of off-diagonal pivots selected, if the |
|
|
531 symmetric or 2-by-2 strategies are used. |
|
|
532 |
|
|
533 Info [UMFPACK_NZDROPPED]: the number of entries smaller in absolute |
|
|
534 value than Control [UMFPACK_DROPTOL] that were dropped from L and U. |
|
|
535 Note that entries on the diagonal of U are never dropped. |
|
|
536 |
|
|
537 Info [UMFPACK_ALL_LNZ]: the number of entries in L, including the |
|
|
538 diagonal, if no small entries are dropped. |
|
|
539 |
|
|
540 Info [UMFPACK_ALL_UNZ]: the number of entries in U, including the |
|
|
541 diagonal, if no small entries are dropped. |
|
|
542 |
|
|
543 Only the above listed Info [...] entries are accessed. The remaining |
|
|
544 entries of Info are not accessed or modified by umfpack_*_numeric. |
|
|
545 Future versions might modify different parts of Info. |
|
|
546 */ |
