|
5164
|
1 /* ========================================================================== */ |
|
|
2 /* === UMFPACK_report_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 /* |
|
|
12 User-callable. Prints the Symbolic object. See umfpack_report_symbolic.h |
|
|
13 for details. Does not print new Cdeg, Rdeg, Esize, and the Diagonal_map. |
|
|
14 |
|
|
15 Dynamic memory usage: Allocates a size MAX (n_row,n_col)*sizeof(Int) |
|
|
16 workspace via a single call to UMF_malloc and then frees all of it via |
|
|
17 UMF_free on return. The workspace is not allocated if an early error |
|
|
18 return occurs before the workspace is needed. |
|
|
19 */ |
|
|
20 |
|
|
21 #include "umf_internal.h" |
|
|
22 #include "umf_valid_symbolic.h" |
|
|
23 #include "umf_report_perm.h" |
|
|
24 #include "umf_malloc.h" |
|
|
25 #include "umf_free.h" |
|
|
26 |
|
|
27 GLOBAL Int UMFPACK_report_symbolic |
|
|
28 ( |
|
|
29 void *SymbolicHandle, |
|
|
30 const double Control [UMFPACK_CONTROL] |
|
|
31 ) |
|
|
32 { |
|
|
33 Int n_row, n_col, nz, nchains, nfr, maxnrows, maxncols, prl, |
|
|
34 k, chain, frontid, frontid1, frontid2, kk, *Chain_start, *W, |
|
|
35 *Chain_maxrows, *Chain_maxcols, *Front_npivcol, *Front_1strow, |
|
|
36 *Front_leftmostdesc, *Front_parent, done, status1, status2 ; |
|
|
37 SymbolicType *Symbolic ; |
|
|
38 |
|
|
39 prl = GET_CONTROL (UMFPACK_PRL, UMFPACK_DEFAULT_PRL) ; |
|
|
40 |
|
|
41 if (prl <= 2) |
|
|
42 { |
|
|
43 return (UMFPACK_OK) ; |
|
|
44 } |
|
|
45 |
|
|
46 PRINTF (("Symbolic object: ")) ; |
|
|
47 |
|
|
48 Symbolic = (SymbolicType *) SymbolicHandle ; |
|
|
49 if (!UMF_valid_symbolic (Symbolic)) |
|
|
50 { |
|
|
51 PRINTF (("ERROR: invalid\n")) ; |
|
|
52 return (UMFPACK_ERROR_invalid_Symbolic_object) ; |
|
|
53 } |
|
|
54 |
|
|
55 n_row = Symbolic->n_row ; |
|
|
56 n_col = Symbolic->n_col ; |
|
|
57 |
|
|
58 nz = Symbolic->nz ; |
|
|
59 |
|
|
60 nchains = Symbolic->nchains ; |
|
|
61 nfr = Symbolic->nfr ; |
|
|
62 maxnrows = Symbolic->maxnrows ; |
|
|
63 maxncols = Symbolic->maxncols ; |
|
|
64 |
|
|
65 Chain_start = Symbolic->Chain_start ; |
|
|
66 Chain_maxrows = Symbolic->Chain_maxrows ; |
|
|
67 Chain_maxcols = Symbolic->Chain_maxcols ; |
|
|
68 Front_npivcol = Symbolic->Front_npivcol ; |
|
|
69 Front_1strow = Symbolic->Front_1strow ; |
|
|
70 Front_leftmostdesc = Symbolic->Front_leftmostdesc ; |
|
|
71 Front_parent = Symbolic->Front_parent ; |
|
|
72 |
|
|
73 if (prl >= 4) |
|
|
74 { |
|
|
75 |
|
|
76 PRINTF (("\n matrix to be factorized:\n")) ; |
|
|
77 PRINTF (("\tn_row: "ID" n_col: "ID"\n", n_row, n_col)) ; |
|
|
78 PRINTF (("\tnumber of entries: "ID"\n", nz)) ; |
|
|
79 PRINTF ((" block size used for dense matrix kernels: "ID"\n", |
|
|
80 Symbolic->nb)) ; |
|
|
81 |
|
|
82 PRINTF ((" strategy used: ")) ; |
|
|
83 /* strategy cannot be auto */ |
|
|
84 if (Symbolic->strategy == UMFPACK_STRATEGY_SYMMETRIC) |
|
|
85 { |
|
|
86 PRINTF (("symmetric")) ; |
|
|
87 } |
|
|
88 else if (Symbolic->strategy == UMFPACK_STRATEGY_UNSYMMETRIC) |
|
|
89 { |
|
|
90 PRINTF (("unsymmetric")) ; |
|
|
91 } |
|
|
92 else if (Symbolic->strategy == UMFPACK_STRATEGY_2BY2) |
|
|
93 { |
|
|
94 PRINTF (("symmetric 2-by-2")) ; |
|
|
95 } |
|
|
96 PRINTF (("\n")) ; |
|
|
97 |
|
|
98 PRINTF ((" ordering used: ")) ; |
|
|
99 if (Symbolic->ordering == UMFPACK_ORDERING_COLAMD) |
|
|
100 { |
|
|
101 PRINTF (("colamd on A\n")) ; |
|
|
102 } |
|
|
103 else if (Symbolic->ordering == UMFPACK_ORDERING_AMD) |
|
|
104 { |
|
|
105 PRINTF (("amd on A+A'\n")) ; |
|
|
106 } |
|
|
107 else if (Symbolic->ordering == UMFPACK_ORDERING_GIVEN) |
|
|
108 { |
|
|
109 PRINTF (("provided by user")) ; |
|
|
110 } |
|
|
111 PRINTF (("\n")) ; |
|
|
112 |
|
|
113 PRINTF ((" performn column etree postorder: ")) ; |
|
|
114 if (Symbolic->fixQ) |
|
|
115 { |
|
|
116 PRINTF (("no\n")) ; |
|
|
117 } |
|
|
118 else |
|
|
119 { |
|
|
120 PRINTF (("yes\n")) ; |
|
|
121 } |
|
|
122 |
|
|
123 PRINTF ((" prefer diagonal pivoting (attempt P=Q): ")) ; |
|
|
124 if (Symbolic->prefer_diagonal) |
|
|
125 { |
|
|
126 PRINTF (("yes\n")) ; |
|
|
127 } |
|
|
128 else |
|
|
129 { |
|
|
130 PRINTF (("no\n")) ; |
|
|
131 } |
|
|
132 |
|
|
133 PRINTF ((" variable-size part of Numeric object:\n")) ; |
|
|
134 PRINTF (("\tminimum initial size (Units): %.20g (MBytes): %.1f\n", |
|
|
135 Symbolic->dnum_mem_init_usage, |
|
|
136 MBYTES (Symbolic->dnum_mem_init_usage))) ; |
|
|
137 PRINTF (("\testimated peak size (Units): %.20g (MBytes): %.1f\n", |
|
|
138 Symbolic->num_mem_usage_est, |
|
|
139 MBYTES (Symbolic->num_mem_usage_est))) ; |
|
|
140 PRINTF (("\testimated final size (Units): %.20g (MBytes): %.1f\n", |
|
|
141 Symbolic->num_mem_size_est, |
|
|
142 MBYTES (Symbolic->num_mem_size_est))) ; |
|
|
143 PRINTF ((" symbolic factorization memory usage (Units):" |
|
|
144 " %.20g (MBytes): %.1f\n", |
|
|
145 Symbolic->peak_sym_usage, |
|
|
146 MBYTES (Symbolic->peak_sym_usage))) ; |
|
|
147 PRINTF ((" frontal matrices / supercolumns:\n")) ; |
|
|
148 PRINTF (("\tnumber of frontal chains: "ID"\n", nchains)) ; |
|
|
149 PRINTF (("\tnumber of frontal matrices: "ID"\n", nfr)) ; |
|
|
150 PRINTF (("\tlargest frontal matrix row dimension: "ID"\n", maxnrows)) ; |
|
|
151 PRINTF (("\tlargest frontal matrix column dimension: "ID"\n",maxncols)); |
|
|
152 } |
|
|
153 |
|
|
154 k = 0 ; |
|
|
155 done = FALSE ; |
|
|
156 |
|
|
157 for (chain = 0 ; chain < nchains ; chain++) |
|
|
158 { |
|
|
159 frontid1 = Chain_start [chain] ; |
|
|
160 frontid2 = Chain_start [chain+1] - 1 ; |
|
|
161 PRINTF4 (("\n Frontal chain: "ID". Frontal matrices "ID" to "ID"\n", |
|
|
162 INDEX (chain), INDEX (frontid1), INDEX (frontid2))) ; |
|
|
163 PRINTF4 (("\tLargest frontal matrix in Frontal chain: "ID"-by-"ID"\n", |
|
|
164 Chain_maxrows [chain], Chain_maxcols [chain])) ; |
|
|
165 for (frontid = frontid1 ; frontid <= frontid2 ; frontid++) |
|
|
166 { |
|
|
167 kk = Front_npivcol [frontid] ; |
|
|
168 PRINTF4 (("\tFront: "ID" pivot cols: "ID" (pivot columns "ID" to " |
|
|
169 ID")\n", INDEX (frontid), kk, INDEX (k), INDEX (k+kk-1))) ; |
|
|
170 PRINTF4 (("\t pivot row candidates: "ID" to "ID"\n", |
|
|
171 INDEX (Front_1strow [Front_leftmostdesc [frontid]]), |
|
|
172 INDEX (Front_1strow [frontid+1]-1))) ; |
|
|
173 PRINTF4 (("\t leftmost descendant: "ID"\n", |
|
|
174 INDEX (Front_leftmostdesc [frontid]))) ; |
|
|
175 PRINTF4 (("\t 1st new candidate row : "ID"\n", |
|
|
176 INDEX (Front_1strow [frontid]))) ; |
|
|
177 PRINTF4 (("\t parent:")) ; |
|
|
178 if (Front_parent [frontid] == EMPTY) |
|
|
179 { |
|
|
180 PRINTF4 ((" (none)\n")) ; |
|
|
181 } |
|
|
182 else |
|
|
183 { |
|
|
184 PRINTF4 ((" "ID"\n", INDEX (Front_parent [frontid]))) ; |
|
|
185 } |
|
|
186 done = (frontid == 20 && frontid < nfr-1 && prl == 4) ; |
|
|
187 if (done) |
|
|
188 { |
|
|
189 PRINTF4 (("\t...\n")) ; |
|
|
190 break ; |
|
|
191 } |
|
|
192 k += kk ; |
|
|
193 } |
|
|
194 if (Front_npivcol [nfr] != 0) |
|
|
195 { |
|
|
196 PRINTF4 (("\tFront: "ID" placeholder for "ID" empty columns\n", |
|
|
197 INDEX (nfr), Front_npivcol [nfr])) ; |
|
|
198 } |
|
|
199 if (done) |
|
|
200 { |
|
|
201 break ; |
|
|
202 } |
|
|
203 } |
|
|
204 |
|
|
205 W = (Int *) UMF_malloc (MAX (n_row, n_col), sizeof (Int)) ; |
|
|
206 if (!W) |
|
|
207 { |
|
|
208 PRINTF (("ERROR: out of memory to check Symbolic object\n\n")) ; |
|
|
209 return (UMFPACK_ERROR_out_of_memory) ; |
|
|
210 } |
|
|
211 |
|
|
212 PRINTF4 (("\nInitial column permutation, Q1: ")) ; |
|
|
213 status1 = UMF_report_perm (n_col, Symbolic->Cperm_init, W, prl, 0) ; |
|
|
214 |
|
|
215 PRINTF4 (("\nInitial row permutation, P1: ")) ; |
|
|
216 status2 = UMF_report_perm (n_row, Symbolic->Rperm_init, W, prl, 0) ; |
|
|
217 |
|
|
218 (void) UMF_free ((void *) W) ; |
|
|
219 |
|
|
220 if (status1 != UMFPACK_OK || status2 != UMFPACK_OK) |
|
|
221 { |
|
|
222 return (UMFPACK_ERROR_invalid_Symbolic_object) ; |
|
|
223 } |
|
|
224 |
|
|
225 PRINTF4 ((" Symbolic object: ")) ; |
|
|
226 PRINTF (("OK\n\n")) ; |
|
|
227 return (UMFPACK_OK) ; |
|
|
228 } |
