1 /* ========================================================================== */
2 /* === Tcov/null2 =========================================================== */
3 /* ========================================================================== */
4
5 /* -----------------------------------------------------------------------------
6 * CHOLMOD/Tcov Module. Copyright (C) 2005-2006, Timothy A. Davis
7 * http://www.suitesparse.com
8 * -------------------------------------------------------------------------- */
9
10 /* Null and error tests, continued. */
11
12 #include "cm.h"
13 #include "amd.h"
14 #ifndef NCAMD
15 #include "camd.h"
16 #endif
17
18 #define CSETSIZE 5
19
20
21 /* ========================================================================== */
22 /* === null2 ================================================================ */
23 /* ========================================================================== */
24
null2(cholmod_triplet * Tok,int do_nantests)25 void null2 (cholmod_triplet *Tok, int do_nantests)
26 {
27 double nm, gsave0, gsave1, r, anorm, beta [2], maxerr, xnan, rcond,
28 ax, az, bx, bz, cx, cz, dx, dz, ex, ez ;
29 cholmod_sparse *A, *C, *AT, *E, *F, *G, *Sok, *R0, *R1, *Aboth, *Axbad, *I1,
30 *Abad, *R, *Acopy, *R3, *Abad2, *I, *I3, *Abad3, *AA, *Rt, *AF, *AFT,
31 *I7, *C2, *R2, *Z ;
32 cholmod_dense *Xok, *Bok, *Two, *X, *W, *XX, *YY, *Xbad2, *B, *Scale,
33 *Y, *X1, *B1, *B2, *X7, *B7 ;
34 cholmod_factor *L, *L2, *L3, *L4, *L5, *L6, *Lcopy, *Lbad, *L7 ;
35 cholmod_triplet *T, *T2, *Tz, *T3 ;
36 Int *fsetok, *Pok, *Flag, *Head, *Cp, *Ci, *P2, *Parent, *Lperm,
37 *Lp, *Li, *Lnz, *Lprev, *Lnext, *Ls, *Lpi, *Lpx, *Super, *Tj, *Ti,
38 *Enz, *Ep, *Post, *Cmember, *CParent, *Partition, *Pinv, *ATi, *ATp,
39 *LColCount, *ColCount, *First, *Level, *fsetbad, *Pbad, *Lz,
40 *R2p, *R2i ;
41 double *Xwork, *Cx, *x, *Lx, *Tx, *Az, *R2x ;
42 size_t size, nznew, gsave2 ;
43 SuiteSparse_long lr ;
44 void *pp, *ii, *jj, *xx ;
45 Int p, i, j, d, nrhs, nrow, ncol, stype, fsizeok, nz, ok, n2, trial, anz,
46 nzmax, cset [CSETSIZE], Axbad_type, isreal, xtype, enz, Lxtype, Cxtype,
47 Xxtype, Txtype, Abad2xtype, k, xtype2, Abad3xtype, save1, save2, save3,
48 save4, ok1, fnz ;
49 int option, asym ;
50 FILE *f ;
51
52 beta [0] = 1e-6 ;
53 beta [1] = 0 ;
54 xnan = 0 ;
55
56 xtype = Tok->xtype ;
57 isreal = (xtype == CHOLMOD_REAL) ;
58
59 /* ---------------------------------------------------------------------- */
60 /* hypot and divcomplex */
61 /* ---------------------------------------------------------------------- */
62
63 maxerr = 0 ;
64 ax = 4.3 ;
65 az = 9.2 ;
66 for (i = 0 ; i <= 1 ; i++)
67 {
68 if (i == 0)
69 {
70 bx = 3.14159 ;
71 bz = -1.2 ;
72 }
73 else
74 {
75 bx = 0.9 ;
76 bz = -1.2 ;
77 }
78 /* c = a/b */
79 CHOLMOD(divcomplex)(ax, az, bx, bz, &cx, &cz) ;
80 /* d = c*b */
81 dx = cx * bx - cz * bz ;
82 dz = cz * bx + cx * bz ;
83 /* e = d-a, which should be zero */
84 ex = dx - ax ;
85 ez = dz - az ;
86 r = CHOLMOD(hypot)(ex, ez) ;
87 MAXERR (maxerr, r, 1) ;
88 OK (r < 1e-14) ;
89 }
90
91 /* ---------------------------------------------------------------------- */
92 /* create objects to test */
93 /* ---------------------------------------------------------------------- */
94
95 printf ("\n------------------------null2 tests:\n") ;
96
97 cm->error_handler = my_handler ;
98
99 CHOLMOD(check_triplet)(Tok, cm) ;
100 nrhs = 5 ;
101 nrow = Tok->nrow ;
102 ncol = Tok->ncol ;
103 d = nrow + 2 ;
104
105 A = CHOLMOD(triplet_to_sparse)(Tok, 0, cm) ; /* [ */
106
107 anorm = CHOLMOD(norm_sparse)(A, 1, cm) ;
108 anz = A->nzmax ;
109
110 AT = CHOLMOD(transpose)(A, 2, cm) ; /* [ */
111
112 printf ("xtrue:\n") ;
113 Xok = xtrue (nrow, nrhs, d, xtype) ; /* [ */
114
115 printf ("rhs:\n") ;
116 Bok = rhs (A, nrhs, d) ; /* [ */
117 printf ("fset:\n") ;
118
119 fsetok = prand (ncol) ; /* [ */ /* RAND */
120 fsetbad = prand (ncol) ; /* [ */ /* RAND */
121
122 if (ncol > 0)
123 {
124 fsetbad [0] = -1 ;
125 }
126 Pbad = prand (nrow) ; /* [ */ /* RAND */
127
128 if (nrow > 0)
129 {
130 Pbad [0] = -1 ;
131 }
132 I1 = CHOLMOD(speye)(nrow+1, nrow+1, xtype, cm) ; /* [ */
133
134 fsizeok = (ncol < 2) ? ncol : (ncol/2) ;
135 Pok = prand (nrow) ; /* [ */ /* RAND */
136
137 R2 = CHOLMOD(allocate_sparse)(nrow, 1, nrow, FALSE, TRUE, 0, /* [ */
138 CHOLMOD_REAL, cm) ;
139 OKP (R2) ;
140
141 R2p = R2->p ;
142 R2i = R2->i ;
143 R2x = R2->x ;
144 for (i = 0 ; i < nrow ; i++)
145 {
146 R2i [i] = Pok [i] ;
147 R2x [i] = 1 ;
148 }
149 R2p [0] = 0 ;
150 R2p [1] = nrow ;
151
152 stype = A->stype ;
153 Two = CHOLMOD(zeros)(1, 1, xtype, cm) ; /* [ */
154 *((double *)(Two->x)) = 2 ;
155
156 Pinv = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ; /* [ */
157 Parent = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
158 Post = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
159 Cmember = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
160 CParent = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
161 Partition = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
162 ColCount = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
163 First = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
164 Level = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
165
166 printf ("etree:\n") ;
167
168 if (AT->stype >= 0)
169 {
170 /* AT is unsymmetric, or symmetric/upper */
171 CHOLMOD(etree)(AT, Parent, cm) ;
172 }
173 else
174 {
175 /* A is symmetric/upper */
176 CHOLMOD(etree)(A, Parent, cm) ;
177 }
178 CHOLMOD(check_parent)(Parent, nrow, cm) ;
179 for (cm->print = 0 ; cm->print <= ((nrow <= 30) ? 5 : 4) ; cm->print++)
180 {
181 CHOLMOD(print_parent)(Parent, nrow, "Parent", cm) ;
182 }
183 cm->print = 1 ;
184
185 /* get row 0 and row 1 of A */
186 R0 = NULL ;
187 R1 = NULL ;
188 Aboth = NULL ;
189 Sok = NULL ;
190
191 if (isreal)
192 {
193 Aboth = CHOLMOD(copy)(A, 0, 1, cm) ; /* [ */
194 Sok = CHOLMOD(copy)(A, 0, 0, cm) ;
195 Aboth->sorted = FALSE ;
196 }
197
198 if (isreal) /* [ */
199 {
200 if (nrow > 1)
201 {
202 cm->print = 4 ;
203 if (nrow < 10)
204 {
205 ok = CHOLMOD(print_sparse)(Aboth, "Aboth", cm) ; OK (ok) ;
206 }
207 i = 0 ;
208 R0 = CHOLMOD(submatrix)(Aboth, &i, 1, NULL, -1, TRUE, TRUE, cm) ;
209 ok = CHOLMOD(print_sparse)(R0, "Row zero", cm) ; OK (ok) ;
210 i = 1 ;
211 R1 = CHOLMOD(submatrix)(Aboth, &i, 1, NULL, -1, TRUE, TRUE, cm) ;
212 ok = CHOLMOD(print_sparse)(R1, "Row one", cm) ; OK (ok) ;
213 Rt = CHOLMOD(transpose)(R1, 1, cm) ;
214
215 C = CHOLMOD(ssmult)(R0, Rt, 0, TRUE, TRUE, cm) ; OKP (C) ;
216 ok = CHOLMOD(print_sparse)(C, "(Row zero)*(Row one)'", cm) ;OK (ok);
217 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
218 ok = CHOLMOD(free_sparse)(&Rt, cm) ; OK (ok) ;
219 cm->print = 1 ;
220 }
221 }
222
223 /* Abad: symmetric but not square, or null if A is square */
224 if (A->nrow != A->ncol)
225 {
226 Abad = CHOLMOD(copy_sparse)(A, cm) ; /* [ */
227 Abad->stype = 1 ;
228 }
229 else
230 {
231 Abad = NULL ;
232 }
233
234 /* Abad2: sparse matrix with invalid xtype */
235 printf ("allocate Abad2:\n") ;
236 Abad2 = CHOLMOD(copy_sparse)(A, cm) ; /* [ */
237 cm->print = 4 ;
238 CHOLMOD(print_sparse)(Abad2, "Abad2", cm) ;
239 cm->print = 1 ;
240 Abad2xtype = Abad2->xtype ;
241 Abad2->xtype = -999 ;
242
243 /* Xbad2: dense matrix with invalid xtype */
244 printf ("allocate Xbad2:\n") ;
245 Xbad2 = CHOLMOD(zeros)(2, 2, CHOLMOD_REAL, cm) ; /* [ */
246 Xbad2->xtype = -911 ;
247
248 /* ---------------------------------------------------------------------- */
249 /* expect lots of errors */
250 /* ---------------------------------------------------------------------- */
251
252 printf ("\n------------------------null2 tests: ERRORs will occur\n") ;
253 cm->error_handler = NULL ;
254
255 /* ---------------------------------------------------------------------- */
256 /* transpose */
257 /* ---------------------------------------------------------------------- */
258
259 C = CHOLMOD(transpose)(Abad2, 1, cm) ; NOP (C) ;
260 ok = CHOLMOD(sort)(Abad2, cm) ; NOT (ok) ;
261 ok = CHOLMOD(sort)(NULL, cm) ; NOT (ok) ;
262
263 if (nrow > 0)
264 {
265 C = CHOLMOD(ptranspose)(A, 1, Pbad, NULL, 0, cm) ; NOP (C) ;
266 }
267
268 C = CHOLMOD(allocate_sparse)(ncol, nrow, anz, TRUE, TRUE,
269 -(A->stype), xtype, cm) ; OKP (C) ;
270 ok = CHOLMOD(transpose_unsym)(A, 1, NULL, NULL, 0,
271 C, cm) ; OK (ok);
272 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
273
274 C = CHOLMOD(allocate_sparse)(ncol, nrow, anz, TRUE, FALSE,
275 -(A->stype), xtype, cm) ; OKP (C) ;
276 ok = CHOLMOD(transpose_unsym)(A, 1, NULL, NULL, 0,
277 C, cm) ; OK (ok);
278 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
279
280 C = CHOLMOD(allocate_sparse)(ncol, nrow, anz, TRUE, FALSE,
281 -(A->stype), xtype, cm) ; OKP (C) ;
282 ok = CHOLMOD(transpose_unsym)(A, 1, Pok, NULL, 0,
283 C, cm) ; OK (ok);
284 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
285
286 C = CHOLMOD(allocate_sparse)(ncol, nrow, anz, TRUE, FALSE,
287 -(A->stype), xtype, cm) ; OKP (C) ;
288 ok = CHOLMOD(transpose_unsym)(A, 1, Pok, fsetok, fsizeok,
289 C, cm) ; OK (ok);
290 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
291
292 C = CHOLMOD(allocate_sparse)(ncol, nrow, anz, TRUE, FALSE,
293 -(A->stype), xtype, cm) ; OKP (C) ;
294 ok = CHOLMOD(transpose_unsym)(A, 1, NULL, fsetok, fsizeok,
295 C, cm) ; OK (ok);
296 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
297
298 C = CHOLMOD(allocate_sparse)(ncol, nrow, anz, TRUE, FALSE,
299 -(A->stype), CHOLMOD_PATTERN, cm) ; OKP (C) ;
300 ok = CHOLMOD(transpose_unsym)(A, 1, NULL, fsetok, fsizeok,
301 C, cm) ; OK (ok);
302
303 E = CHOLMOD(allocate_sparse)(nrow, ncol, anz, TRUE, FALSE,
304 (A->stype), CHOLMOD_PATTERN, cm) ; OKP (C) ;
305 enz = CHOLMOD(nnz)(E, cm) ;
306 OK (enz == 0) ;
307 ok = CHOLMOD(transpose_unsym)(C, 1, NULL, Pok, nrow,
308 E, cm) ; OK (ok);
309 ok = CHOLMOD(free_sparse)(&E, cm) ; OK (ok) ;
310
311 if (A->nrow != A->ncol)
312 {
313 ok = CHOLMOD(transpose_sym)(A, 1, NULL, C, cm) ; NOT (ok) ;
314 }
315 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
316
317 /* Abad3: sparse matrix with invalid xtype [ */
318 printf ("allocate Abad3:\n") ;
319 C = CHOLMOD(copy_sparse)(A, cm) ;
320 Abad3 = CHOLMOD(transpose)(A, 1, cm) ; OKP (Abad3) ;
321 E = CHOLMOD(transpose)(A, 1, cm) ; OKP (E) ;
322 Abad3xtype = Abad3->xtype ;
323 Abad3->xtype = -999 ;
324
325 ok = CHOLMOD(transpose_sym)(C, 1, NULL, Abad3, cm) ; NOT (ok) ;
326 ok = CHOLMOD(transpose_sym)(Abad3, 1, NULL, C, cm) ; NOT (ok) ;
327 ok = CHOLMOD(transpose_unsym)(C, 1, NULL, NULL, 0, Abad3, cm) ;NOT (ok);
328 ok = CHOLMOD(transpose_unsym)(Abad3, 1, NULL, NULL, 0, C, cm) ;NOT (ok);
329
330 switch (xtype)
331 {
332 case CHOLMOD_REAL:
333 CHOLMOD(sparse_xtype)(CHOLMOD_COMPLEX, E, cm) ;
334 break ;
335 case CHOLMOD_COMPLEX:
336 CHOLMOD(sparse_xtype)(CHOLMOD_ZOMPLEX, E, cm) ;
337 break ;
338 case CHOLMOD_ZOMPLEX:
339 CHOLMOD(sparse_xtype)(CHOLMOD_COMPLEX, E, cm) ;
340 break ;
341 }
342
343 printf ("mismatch start [:\n") ;
344 ok = CHOLMOD(transpose_sym)(C, 1, NULL, E, cm) ; NOT (ok) ;
345 ok = CHOLMOD(transpose_sym)(E, 1, NULL, C, cm) ; NOT (ok) ;
346 ok = CHOLMOD(transpose_sym)(C, 2, NULL, E, cm) ; NOT (ok) ;
347 ok = CHOLMOD(transpose_sym)(E, 2, NULL, C, cm) ; NOT (ok) ;
348 ok = CHOLMOD(transpose_unsym)(C, 1, NULL, NULL, 0, E, cm) ; NOT (ok);
349 ok = CHOLMOD(transpose_unsym)(E, 1, NULL, NULL, 0, C, cm) ; NOT (ok);
350 ok = CHOLMOD(transpose_unsym)(C, 2, NULL, NULL, 0, E, cm) ; NOT (ok);
351 ok = CHOLMOD(transpose_unsym)(E, 2, NULL, NULL, 0, C, cm) ; NOT (ok);
352 printf ("mismatch done ]\n") ;
353
354 printf ("wrong dim [:\n") ;
355 ok = CHOLMOD(transpose_sym)(C, 1, NULL, I1, cm) ; NOT (ok) ;
356 ok = CHOLMOD(transpose_sym)(I1, 1, NULL, C, cm) ; NOT (ok) ;
357 ok = CHOLMOD(transpose_unsym)(C, 1, NULL, NULL, 0, I1, cm) ; NOT (ok);
358 ok = CHOLMOD(transpose_unsym)(I1, 1, NULL, NULL, 0, C, cm) ; NOT (ok);
359 ok = CHOLMOD(transpose_unsym)(C, 2, NULL, NULL, 0, I1, cm) ; NOT (ok);
360 ok = CHOLMOD(transpose_unsym)(I1, 2, NULL, NULL, 0, C, cm) ; NOT (ok);
361 printf ("wrong dim ]\n") ;
362
363 nz = CHOLMOD(nnz)(C, cm) ;
364 if (nz > 10)
365 {
366 printf ("F too small [:\n") ;
367 F = CHOLMOD(allocate_sparse)(C->ncol, C->nrow, C->nzmax-5, TRUE, TRUE,
368 -(C->stype), C->xtype, cm) ; OKP (F) ;
369 ok = CHOLMOD(transpose_sym)(C, 1, NULL, F, cm) ; NOT (ok) ;
370 ok = CHOLMOD(transpose_unsym)(C, 1, NULL, NULL, 0, F, cm) ; NOT (ok);
371 CHOLMOD(free_sparse)(&F, cm) ;
372 printf ("F too small ]\n") ;
373 }
374
375 ok = CHOLMOD(transpose_unsym)(C, 1, NULL, NULL, 0, NULL, cm) ; NOT (ok);
376 ok = CHOLMOD(transpose_unsym)(NULL, 1, NULL, NULL, 0, C, cm) ; NOT (ok);
377
378 ok = CHOLMOD(transpose_sym)(C, 1, NULL, NULL, cm) ; NOT (ok);
379 ok = CHOLMOD(transpose_sym)(NULL, 1, NULL, C, cm) ; NOT (ok);
380
381 CHOLMOD(free_sparse)(&C, cm) ;
382 CHOLMOD(free_sparse)(&E, cm) ;
383
384 Abad3->xtype = Abad3xtype ;
385 CHOLMOD(free_sparse)(&Abad3, cm) ; /* ] */
386
387 cm->status = CHOLMOD_OK ;
388
389 /* ---------------------------------------------------------------------- */
390 /* aat */
391 /* ---------------------------------------------------------------------- */
392
393 C = CHOLMOD(aat)(NULL, NULL, 0, 0, cm) ; NOP (C) ;
394 if (stype)
395 {
396 C = CHOLMOD(aat)(A, fsetok, fsizeok, 0, cm) ;
397 NOP (C) ;
398 }
399 else
400 {
401 C = CHOLMOD(aat)(A, fsetok, fsizeok, 0, cm) ; OKP (C) ;
402 CHOLMOD(free_sparse)(&C, cm) ;
403 C = CHOLMOD(aat)(Abad2, fsetok, fsizeok, 0, cm) ; NOP (C) ;
404 }
405
406 /* ---------------------------------------------------------------------- */
407 /* add */
408 /* ---------------------------------------------------------------------- */
409
410 C = CHOLMOD(add)(A, NULL, one, one, TRUE, TRUE, cm) ; NOP (C) ;
411 C = CHOLMOD(add)(NULL, AT, one, one, TRUE, TRUE, cm) ; NOP (C) ;
412
413 C = CHOLMOD(add)(A, AT, one, one, TRUE, TRUE, cm) ;
414 if (A->nrow == A->ncol && isreal)
415 {
416 OKP (C) ;
417 /* C should equal 2*A if A=A' */
418 if (stype)
419 {
420 double *s ;
421
422 E = CHOLMOD(copy_sparse)(A, cm) ;
423 CHOLMOD(scale)(Two, CHOLMOD_SCALAR, E, cm) ;
424 F = CHOLMOD(add)(C, E, one, minusone, TRUE, TRUE, cm) ;
425 CHOLMOD(drop)(0., F, cm) ;
426 nz = CHOLMOD(nnz)(F, cm) ;
427 OK (nz == 0) ;
428 CHOLMOD(free_sparse)(&E, cm) ;
429 CHOLMOD(free_sparse)(&F, cm) ;
430
431 Scale = CHOLMOD(zeros)(nrow, 1, CHOLMOD_REAL, cm) ;
432
433 s = Scale->x ;
434 for (i = 0 ; i < nrow ; i++)
435 {
436 s [i] = 2 ;
437 }
438 E = CHOLMOD(copy_sparse)(A, cm) ;
439 CHOLMOD(scale)(Scale, CHOLMOD_ROW, E, cm) ;
440 F = CHOLMOD(add)(C, E, one, minusone, TRUE, TRUE, cm) ;
441 CHOLMOD(drop)(0., F, cm) ;
442 nz = CHOLMOD(nnz)(F, cm) ;
443 r = CHOLMOD(norm_sparse)(F, 0, cm) ;
444 OK (nz == 0) ;
445 CHOLMOD(free_sparse)(&E, cm) ;
446 CHOLMOD(free_sparse)(&F, cm) ;
447
448 E = CHOLMOD(copy_sparse)(A, cm) ;
449 CHOLMOD(scale)(Scale, CHOLMOD_COL, E, cm) ;
450 F = CHOLMOD(add)(C, E, one, minusone, TRUE, TRUE, cm) ;
451 CHOLMOD(drop)(0., F, cm) ;
452 nz = CHOLMOD(nnz)(F, cm) ;
453 r = CHOLMOD(norm_sparse)(F, 0, cm) ;
454 OK (nz == 0) ;
455 CHOLMOD(free_sparse)(&E, cm) ;
456 CHOLMOD(free_sparse)(&F, cm) ;
457
458 for (i = 0 ; i < nrow ; i++)
459 {
460 s [i] = sqrt (2) ;
461 }
462 E = CHOLMOD(copy_sparse)(A, cm) ;
463 CHOLMOD(scale)(Scale, CHOLMOD_SYM, E, cm) ;
464 F = CHOLMOD(add)(C, E, one, minusone, TRUE, TRUE, cm) ;
465 CHOLMOD(drop)(0., F, cm) ;
466 nz = CHOLMOD(nnz)(F, cm) ;
467 r = CHOLMOD(norm_sparse)(F, 0, cm) ;
468 OK (r < 1e-12*anorm) ;
469
470 Scale->x = NULL ;
471 CHOLMOD(scale)(Scale, CHOLMOD_SYM, E, cm) ;
472 Scale->x = s ;
473
474 OKP (E) ;
475 OKP (cm) ;
476 ok = CHOLMOD(scale)(NULL, CHOLMOD_ROW, E, cm) ; NOT (ok) ;
477 ok = CHOLMOD(scale)(Scale, CHOLMOD_SYM, NULL, cm) ; NOT (ok) ;
478 ok = CHOLMOD(scale)(NULL, CHOLMOD_SYM, NULL, cm) ; NOT (ok) ;
479 ok = CHOLMOD(scale)(Scale, -1, E, cm) ; NOT (ok) ;
480
481 CHOLMOD(free_sparse)(&E, cm) ;
482 CHOLMOD(free_sparse)(&F, cm) ;
483 CHOLMOD(free_dense)(&Scale, cm) ;
484
485 }
486 CHOLMOD(free_sparse)(&C, cm) ;
487 }
488 else
489 {
490 NOP (C) ;
491 }
492
493 Axbad = CHOLMOD(copy_sparse)(A, cm) ; /* [ */
494 Axbad_type = Axbad->xtype ;
495 Axbad->xtype = CHOLMOD_COMPLEX ;
496 C = CHOLMOD(add)(A, Axbad, one, one, TRUE, TRUE, cm) ; NOP (C) ;
497
498 if (nrow > 1 && xtype == CHOLMOD_REAL)
499 {
500 /* C = A (0,:) + A (1,:) */
501 C = CHOLMOD(add)(R0, R1, one, one, TRUE, TRUE, cm) ; OKP (C) ;
502 OK (CHOLMOD(check_sparse)(C, cm)) ;
503 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
504 }
505 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
506 ok = CHOLMOD(free_sparse)(NULL, cm) ; OK (ok) ;
507
508 /* ---------------------------------------------------------------------- */
509 /* sparse */
510 /* ---------------------------------------------------------------------- */
511
512 cm->print = 4 ;
513
514 ok = CHOLMOD(reallocate_sparse)(10, NULL, cm) ; NOT (ok) ;
515 C = CHOLMOD(allocate_sparse)(10, 10, 10, TRUE, TRUE, 0, -1, cm) ; NOP (C) ;
516 ok = CHOLMOD(reallocate_sparse)(Abad2->nzmax, Abad2, cm) ; NOT (ok) ;
517 C = CHOLMOD(copy_sparse)(Abad2, cm) ; NOP (C) ;
518 C = CHOLMOD(allocate_sparse)(2, 3, 6, TRUE, TRUE, 1, 0, cm) ; NOP (C) ;
519
520 C = CHOLMOD(copy)(A, 0, -1, cm) ; OKP (C) ;
521 E = unpack (C) ; OKP (E) ;
522 F = CHOLMOD(copy_sparse)(E, cm) ; OKP (F) ;
523 ok = CHOLMOD(sparse_xtype)(CHOLMOD_REAL, C, cm) ; OK (ok) ;
524 ok = CHOLMOD(sparse_xtype)(CHOLMOD_REAL, F, cm) ; OK (ok) ;
525 /* G = C-F */
526 G = CHOLMOD(add)(C, F, one, minusone, TRUE, FALSE, cm) ; OKP (G) ;
527 ok = CHOLMOD(drop)(0., G, cm) ; OK (ok) ;
528 nz = CHOLMOD(nnz)(G, cm) ;
529 CHOLMOD(print_sparse)(C, "C", cm) ;
530 CHOLMOD(print_sparse)(E, "E", cm) ;
531 CHOLMOD(print_sparse)(F, "F", cm) ;
532 CHOLMOD(print_sparse)(G, "G", cm) ;
533
534 OK (nz == 0) ;
535 CHOLMOD(free_sparse)(&C, cm) ;
536 CHOLMOD(free_sparse)(&E, cm) ;
537 CHOLMOD(free_sparse)(&F, cm) ;
538 CHOLMOD(free_sparse)(&G, cm) ;
539
540 cm->print = 1 ;
541
542 /* ---------------------------------------------------------------------- */
543 /* scale */
544 /* ---------------------------------------------------------------------- */
545
546 ok = CHOLMOD(scale)(Two, -1, C, cm) ; NOT (ok) ;
547 if (nrow > 1)
548 {
549 E = CHOLMOD(copy_sparse)(A, cm) ; OKP (E) ;
550 CHOLMOD(scale)(Two, CHOLMOD_ROW, E, cm) ; NOT (ok) ;
551 ok = CHOLMOD(free_sparse)(&E, cm) ; OK (ok) ;
552 }
553
554 /* ---------------------------------------------------------------------- */
555 /* amd */
556 /* ---------------------------------------------------------------------- */
557
558 ok = CHOLMOD(amd)(NULL, NULL, 0, NULL, cm) ; NOT (ok) ;
559 ok = CHOLMOD(amd)(A, NULL, 0, NULL, cm) ; NOT (ok) ;
560 ok = CHOLMOD(amd)(NULL, NULL, 0, Pok, cm) ; NOT (ok) ;
561 ok = CHOLMOD(amd)(A, NULL, 0, Pok, cm) ; OK (ok) ;
562 cm->current = -1 ;
563 ok = CHOLMOD(amd)(A, NULL, 0, Pok, cm) ; OK (ok) ;
564 cm->current = 0 ;
565 ok = CHOLMOD(print_perm)(Pok, nrow, nrow, "AMD perm", cm) ; OK (ok) ;
566 i = cm->print ;
567 cm->print = 4 ;
568 if (A->nrow < 1000 && isreal)
569 {
570 CHOLMOD(print_sparse)(Aboth, "Aboth", cm) ;
571 ok = CHOLMOD(amd)(Aboth, NULL, 0, Pok, cm) ; OK (ok) ;
572 }
573 cm->print = i ;
574 ok = CHOLMOD(amd)(Abad2, NULL, 0, Pok, cm) ; NOT (ok) ;
575
576 /* ---------------------------------------------------------------------- */
577 /* camd */
578 /* ---------------------------------------------------------------------- */
579
580 #ifndef NCAMD
581 ok = CHOLMOD(camd)(NULL, NULL, 0, NULL, NULL, cm) ; NOT (ok) ;
582 ok = CHOLMOD(camd)(A, NULL, 0, NULL, NULL, cm) ; NOT (ok) ;
583 ok = CHOLMOD(camd)(NULL, NULL, 0, NULL, Pok, cm) ; NOT (ok) ;
584 ok = CHOLMOD(camd)(A, NULL, 0, NULL, Pok, cm) ; OK (ok) ;
585 cm->current = -1 ;
586 ok = CHOLMOD(camd)(A, NULL, 0, NULL, Pok, cm) ; OK (ok) ;
587 cm->current = 0 ;
588 ok = CHOLMOD(print_perm)(Pok, nrow, nrow, "CAMD perm", cm) ; OK (ok) ;
589 i = cm->print ;
590 cm->print = 4 ;
591 if (A->nrow < 1000 && isreal)
592 {
593 CHOLMOD(print_sparse)(Aboth, "Aboth", cm) ;
594 ok = CHOLMOD(camd)(Aboth, NULL, 0, NULL, Pok, cm) ; OK (ok) ;
595 }
596 cm->print = i ;
597 ok = CHOLMOD(camd)(Abad2, NULL, 0, NULL, Pok, cm) ; NOT (ok) ;
598 #endif
599
600 /* ---------------------------------------------------------------------- */
601 /* analyze */
602 /* ---------------------------------------------------------------------- */
603
604 cm->nmethods = 1 ;
605 cm->method [0].ordering = -1 ;
606 ok = CHOLMOD(print_common)("Bad cm", cm) ; NOT (ok) ;
607 ok = CHOLMOD(analyze_ordering)(NULL, 0, NULL, NULL, 0,
608 NULL, NULL, NULL, NULL, NULL, cm) ; NOT (ok) ;
609 L = CHOLMOD(analyze)(NULL, cm) ; NOP (L) ;
610 L = CHOLMOD(analyze)(Abad2, cm) ; NOP (L) ;
611 L = CHOLMOD(analyze)(A, cm) ; NOP (L) ;
612
613 /* test AMD backup strategy */
614 cm->nmethods = 2 ;
615 cm->method [0].ordering = -1 ;
616 cm->method [1].ordering = -1 ;
617 L = CHOLMOD(analyze)(A, cm) ; OKP (L) ;
618
619 cm->nmethods = 0 ; /* restore defaults */
620 cm->method [0].ordering = CHOLMOD_GIVEN ;
621 cm->method [1].ordering = CHOLMOD_AMD ;
622 cm->print = 4 ;
623 ok = CHOLMOD(print_common)("OKcm", cm) ; OK (ok) ;
624 ok = CHOLMOD(print_factor)(L, "L symbolic", cm) ; OK (ok) ;
625 cm->print = 1 ;
626 ok = CHOLMOD(free_factor)(&L, cm) ; OK (ok) ;
627 ok = CHOLMOD(free_factor)(&L, cm) ; OK (ok) ;
628 ok = CHOLMOD(free_factor)(NULL, cm) ; OK (ok) ;
629
630 /* ---------------------------------------------------------------------- */
631 /* band */
632 /* ---------------------------------------------------------------------- */
633
634 C = CHOLMOD(band)(NULL, 0, 0, 0, cm) ; NOP (C) ;
635 C = CHOLMOD(band)(Abad2, 0, 0, 0, cm) ; NOP (C) ;
636
637 /* ---------------------------------------------------------------------- */
638 /* ccolamd */
639 /* ---------------------------------------------------------------------- */
640
641 #ifndef NCAMD
642 ok = CHOLMOD(ccolamd)(NULL, fsetok, fsizeok, NULL, Pok, cm) ; NOT (ok) ;
643 ok = CHOLMOD(ccolamd)(A, fsetok, fsizeok, NULL, NULL, cm) ; NOT (ok) ;
644
645 ok = CHOLMOD(ccolamd)(A, fsetok, fsizeok, NULL, Pok, cm) ;
646 if (stype)
647 {
648 NOT (ok) ;
649 }
650 else
651 {
652 OK (ok) ;
653 }
654
655 cm->current = -1 ;
656 ok = CHOLMOD(ccolamd)(A, fsetok, fsizeok, NULL, Pok, cm) ;
657 cm->current = 0 ;
658 if (stype)
659 {
660 NOT (ok) ;
661 }
662 else
663 {
664 OK (ok) ;
665 }
666 #endif
667
668 /* ---------------------------------------------------------------------- */
669 /* copy */
670 /* ---------------------------------------------------------------------- */
671
672 CHOLMOD(print_sparse)(Abad, "Abad", cm) ;
673
674 C = CHOLMOD(copy)(Abad, 0, 1, cm) ;
675 CHOLMOD(print_sparse)(C, "copy of Abad", cm) ;
676 NOP (C) ;
677
678 C = CHOLMOD(copy_sparse)(Abad, cm) ;
679 CHOLMOD(print_sparse)(C, "another copy of Abad", cm) ;
680 NOP (C) ;
681
682 C = CHOLMOD(copy)(A, 0, -1, cm) ; OKP (C) ;
683 OK (nzdiag (C) == 0) ;
684
685 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
686
687 /* ---------------------------------------------------------------------- */
688 /* submatrix */
689 /* ---------------------------------------------------------------------- */
690
691 if (A->nrow == A->ncol)
692 {
693 /* submatrix cannot operation on symmetric matrices */
694 C = CHOLMOD(copy)(A, 1, 0, cm) ; OKP (C) ;
695 E = CHOLMOD(submatrix)(C, NULL, -1, NULL, -1, TRUE, TRUE, cm); NOP (E) ;
696 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
697 }
698
699 E = CHOLMOD(submatrix)(Abad2, NULL, -1, NULL, -1, TRUE, TRUE, cm) ; NOP(E) ;
700
701 if (A->stype == 0 && isreal)
702 {
703 /* E = A(:,:) */
704 E = CHOLMOD(submatrix)(NULL, NULL,-1, NULL,-1, TRUE, TRUE, cm) ; NOP(E);
705 E = CHOLMOD(submatrix)(A, NULL, -1, NULL, -1, TRUE, TRUE, cm) ; OKP(E) ;
706 /* C = A-E */
707 C = CHOLMOD(add)(A, E, one, minusone, TRUE, TRUE, cm) ; OKP (C) ;
708 ok = CHOLMOD(drop)(0., C, cm) ; OK (ok) ;
709 ok = CHOLMOD(drop)(0., Abad2, cm) ; NOT(ok) ;
710 nz = CHOLMOD(nnz)(C, cm) ;
711 OK (nz == 0) ;
712 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
713 ok = CHOLMOD(free_sparse)(&E, cm) ; OK (ok) ;
714
715 i = -1 ;
716 E = CHOLMOD(submatrix)(A, &i, 1, NULL, -1, TRUE, TRUE, cm) ; NOP(E) ;
717 E = CHOLMOD(submatrix)(A, NULL, -1, &i, 1, TRUE, TRUE, cm) ; NOP(E) ;
718 E = CHOLMOD(submatrix)(A, &i, 1, &i, 1, TRUE, TRUE, cm) ; NOP(E) ;
719 i = 0 ;
720 j = -1 ;
721 E = CHOLMOD(submatrix)(A, &i, 1, &j, 1, TRUE, TRUE, cm) ; NOP(E) ;
722 }
723
724 /* ---------------------------------------------------------------------- */
725 /* read */
726 /* ---------------------------------------------------------------------- */
727
728 C = CHOLMOD(read_sparse)(NULL, cm) ; NOP (C) ;
729 X = CHOLMOD(read_dense)(NULL, cm) ; NOP (X) ;
730 pp = CHOLMOD(read_matrix)(NULL, 1, NULL, cm) ; NOP (pp) ;
731 pp = CHOLMOD(read_matrix)((FILE *) 1, 1, NULL, cm) ; NOP (pp) ;
732 T3 = CHOLMOD(read_triplet)(NULL, cm) ; NOP (T3) ;
733
734 /* ---------------------------------------------------------------------- */
735 /* write */
736 /* ---------------------------------------------------------------------- */
737
738 asym = CHOLMOD(write_sparse) (NULL, NULL, NULL, NULL, cm) ; NOT (asym>=0);
739 asym = CHOLMOD(write_sparse) ((FILE *) 1, NULL, NULL, NULL, cm) ;
740 NOT (asym>=0);
741
742 asym = CHOLMOD(write_dense) (NULL, NULL, NULL, cm) ; NOT (asym>=0);
743 asym = CHOLMOD(write_dense) ((FILE *) 1, NULL, NULL, cm) ; NOT (asym>=0);
744
745 f = fopen ("temp4.mtx", "w") ;
746 asym = CHOLMOD(write_sparse) (f, A, NULL, "garbage.txt", cm) ;
747 fclose (f) ;
748 printf ("write_sparse, asym: %d\n", asym) ;
749 OK (asym == EMPTY) ;
750
751 if (A != NULL)
752 {
753 save1 = A->xtype ;
754 A->xtype = 999 ;
755 f = fopen ("temp4.mtx", "w") ;
756 asym = CHOLMOD(write_sparse) (f, A, NULL, NULL, cm) ;
757 fclose (f) ;
758 printf ("write_sparse, asym: %d\n", asym) ;
759 OK (asym == EMPTY) ;
760 A->xtype = save1 ;
761 }
762
763 Z = CHOLMOD(speye) (nrow+1, ncol+1, CHOLMOD_PATTERN, cm) ;
764 f = fopen ("temp4.mtx", "w") ;
765 asym = CHOLMOD(write_sparse) (f, A, Z, NULL, cm) ;
766 fclose (f) ;
767 printf ("write_sparse, asym: %d with Z\n", asym) ;
768 OK (asym == EMPTY) ;
769
770 Z->xtype = 999 ;
771 f = fopen ("temp4.mtx", "w") ;
772 asym = CHOLMOD(write_sparse) (f, A, Z, NULL, cm) ;
773 fclose (f) ;
774 printf ("write_sparse, asym: %d with Z2\n", asym) ;
775 OK (asym == EMPTY) ;
776 Z->xtype = CHOLMOD_PATTERN ;
777
778 CHOLMOD(free_sparse) (&Z, cm) ;
779
780 Z = CHOLMOD(speye) (0, ncol+1, CHOLMOD_PATTERN, cm) ;
781 f = fopen ("temp4.mtx", "w") ;
782 asym = CHOLMOD(write_sparse) (f, A, Z, NULL, cm) ;
783 fclose (f) ;
784 printf ("write_sparse, asym: %d with Z\n", asym) ;
785 if (A == NULL)
786 {
787 OK (asym == EMPTY) ;
788 }
789 else
790 {
791 OK (asym > EMPTY) ;
792 }
793 CHOLMOD(free_sparse) (&Z, cm) ;
794
795 X = CHOLMOD(ones) (4, 4, CHOLMOD_REAL, cm) ;
796 f = fopen ("temp6.mtx", "w") ;
797 asym = CHOLMOD(write_dense) (f, X, "garbage.txt", cm) ;
798 fclose (f) ;
799 OK (asym == EMPTY) ;
800
801 X->xtype = 999 ;
802 f = fopen ("temp6.mtx", "w") ;
803 asym = CHOLMOD(write_dense) (f, X, NULL, cm) ;
804 fclose (f) ;
805 OK (asym == EMPTY) ;
806 X->xtype = CHOLMOD_REAL ;
807 CHOLMOD(free_dense) (&X, cm) ;
808
809 /* ---------------------------------------------------------------------- */
810 /* print_common */
811 /* ---------------------------------------------------------------------- */
812
813 cm->print = 4 ;
814 ok = CHOLMOD(print_common)("Null", NULL) ; NOT (ok) ;
815 for (cm->status = CHOLMOD_INVALID ; cm->status <= CHOLMOD_DSMALL ;
816 cm->status++)
817 {
818 ok = CHOLMOD(print_common)("status", cm) ; OK (ok) ;
819 }
820 cm->status = 999 ;
821 ok = CHOLMOD(print_common)("bad status", cm) ; NOT (ok) ;
822 cm->status = CHOLMOD_OK ;
823
824 Flag = cm->Flag ;
825 cm->Flag = NULL ;
826 ok = CHOLMOD(print_common)("bad Flag", cm) ; NOT (ok) ;
827 cm->Flag = Flag ;
828 ok = CHOLMOD(print_common)("ok Flag", cm) ; OK (ok) ;
829
830 Flag [0] = Int_max ;
831 ok = CHOLMOD(print_common)("bad Flag", cm) ; NOT (ok) ;
832 Flag [0] = -1 ;
833 ok = CHOLMOD(print_common)("ok Flag", cm) ; OK (ok) ;
834
835 Head = cm->Head ;
836 cm->Head = NULL ;
837 ok = CHOLMOD(print_common)("bad Head", cm) ; NOT (ok) ;
838 cm->Head = Head ;
839 ok = CHOLMOD(print_common)("ok Head", cm) ; OK (ok) ;
840
841 Head [0] = Int_max ;
842 ok = CHOLMOD(print_common)("bad Head", cm) ; NOT (ok) ;
843 Head [0] = -1 ;
844 ok = CHOLMOD(print_common)("ok Head", cm) ; OK (ok) ;
845
846 Xwork = cm->Xwork ;
847 cm->Xwork = NULL ;
848 ok = CHOLMOD(print_common)("bad Xwork", cm) ; NOT (ok) ;
849 cm->Xwork = Xwork ;
850 ok = CHOLMOD(print_common)("ok Xwork", cm) ; OK (ok) ;
851
852 Xwork [0] = 1 ;
853 ok = CHOLMOD(print_common)("bad Xwork", cm) ; NOT (ok) ;
854 Xwork [0] = 0 ;
855 ok = CHOLMOD(print_common)("ok Xwork", cm) ; OK (ok) ;
856
857 p = cm->nmethods ;
858 i = cm->method [0].ordering ;
859 cm->nmethods = 1 ;
860 cm->method [0].ordering = 999 ;
861 ok = CHOLMOD(print_common)("bad method", cm) ; NOT (ok) ;
862 cm->nmethods = p ;
863 cm->method [0].ordering = i ;
864
865 /* ---------------------------------------------------------------------- */
866 /* print_sparse */
867 /* ---------------------------------------------------------------------- */
868
869 C = CHOLMOD(copy_sparse)(A, cm) ; OKP (C) ;
870
871 cm->print = 3 ;
872 C->itype = EMPTY ;
873 ok = CHOLMOD(print_sparse)(C, "CIbad", cm) ; NOT (ok) ;
874 C->itype = CHOLMOD_INTLONG ;
875 ok = CHOLMOD(print_sparse)(C, "Cibad", cm) ; NOT (ok) ;
876 C->itype = cm->itype ;
877 cm->print = 1 ;
878
879 cm->print = 4 ;
880 #ifdef LONG
881 C->itype = CHOLMOD_INT ;
882 #else
883 C->itype = CHOLMOD_LONG ;
884 #endif
885 ok = CHOLMOD(print_sparse)(C, "Cibad2", cm) ; NOT (ok) ;
886 C->itype = cm->itype ;
887 cm->print = 1 ;
888
889 C->dtype = CHOLMOD_SINGLE ;
890 ok = CHOLMOD(print_sparse)(C, "Cdbad", cm) ; NOT (ok) ;
891 C->dtype = EMPTY ;
892 ok = CHOLMOD(print_sparse)(C, "CDbad", cm) ; NOT (ok) ;
893 C->dtype = CHOLMOD_DOUBLE ;
894
895 Cxtype = C->xtype ;
896 C->xtype = EMPTY ;
897 ok = CHOLMOD(print_sparse)(C, "CXbad", cm) ; NOT (ok) ;
898 C->xtype = Cxtype ;
899
900 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
901
902 Cp = C->p ;
903 Ci = C->i ;
904 Cx = C->x ;
905
906 C->p = NULL ;
907 ok = CHOLMOD(print_sparse)(C, "Cp bad", cm) ; NOT (ok) ;
908 C->p = Cp ;
909 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
910
911 C->i = NULL ;
912 ok = CHOLMOD(print_sparse)(C, "Ci bad", cm) ; NOT (ok) ;
913 C->i = Ci ;
914 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
915
916 C->x = NULL ;
917 ok = CHOLMOD(print_sparse)(C, "Cx bad", cm) ; NOT (ok) ;
918 C->x = Cx ;
919 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
920
921 Cp [0] = 42 ;
922 ok = CHOLMOD(print_sparse)(C, "Cp [0] bad", cm) ; NOT (ok) ;
923 Cp [0] = 0 ;
924 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
925
926 p = Cp [ncol] ;
927 Cp [ncol] = C->nzmax + 10 ;
928 ok = CHOLMOD(print_sparse)(C, "Cp [ncol] bad", cm) ; NOT (ok) ;
929 Cp [ncol] = p ;
930 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
931
932 p = Cp [ncol] ;
933 Cp [ncol] = -1 ;
934 ok = CHOLMOD(print_sparse)(C, "Cp [ncol] neg", cm) ; NOT (ok) ;
935 Cp [ncol] = p ;
936 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
937
938 if (ncol > 0)
939 {
940 p = Cp [1] ;
941 Cp [1] = 2*nrow + 1 ;
942 ok = CHOLMOD(print_sparse)(C, "Cp [1] bad", cm) ; NOT (ok) ;
943 Cp [1] = p ;
944 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
945 }
946
947 if (ncol > 2)
948 {
949 p = Cp [2] ;
950 Cp [2] = Cp [1] - 1 ;
951 ok = CHOLMOD(print_sparse)(C, "Cp [2] bad", cm) ; NOT (ok) ;
952 Cp [2] = p ;
953 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
954 }
955
956 if (Cp [ncol] > 0)
957 {
958 i = Ci [0] ;
959 Ci [0] = -1 ;
960 ok = CHOLMOD(print_sparse)(C, "Ci [0] neg", cm) ; NOT (ok) ;
961 Ci [0] = i ;
962 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
963 }
964
965 if (ncol > 0 && C->sorted && Cp [1] - Cp [0] > 2)
966 {
967 i = Ci [0] ;
968 Ci [0] = nrow-1 ;
969 ok = CHOLMOD(print_sparse)(C, "Ci [0] unsorted", cm) ; NOT (ok) ;
970 Ci [0] = i ;
971 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
972 }
973
974 if (ncol > 0 && C->sorted && ncol > 2 && Cp [1] - Cp [0] > 2)
975 {
976 /* swap the first two entries */
977 p = Ci [0] ;
978 Ci [0] = Ci [1] ;
979 Ci [1] = p ;
980 ok = CHOLMOD(print_sparse)(C, "Ci [0] unsorted", cm) ; NOT (ok) ;
981 C->sorted = FALSE ;
982 ok = CHOLMOD(print_sparse)(C, "Ci [0] unsorted", cm) ; OK (ok) ;
983 Ci [1] = Ci [0] ;
984 ok = CHOLMOD(print_sparse)(C, "Ci [0] duplicate", cm) ; NOT (ok) ;
985 Ci [1] = p ;
986 ok = CHOLMOD(print_sparse)(C, "Ci [0] unsorted", cm) ; OK (ok) ;
987 p = Ci [0] ;
988 Ci [0] = Ci [1] ;
989 Ci [1] = p ;
990 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
991 C->sorted = TRUE ;
992 ok = CHOLMOD(print_sparse)(C, "C ok", cm) ; OK (ok) ;
993 }
994
995 E = CHOLMOD(copy_sparse)(C, cm) ; OKP (E) ;
996 Enz = CHOLMOD(malloc)(ncol, sizeof (Int), cm) ; OKP (Enz) ;
997 E->nz = Enz ;
998 Ep = E->p ;
999 for (j = 0 ; j < ncol ; j++)
1000 {
1001 Enz [j] = Ep [j+1] - Ep [j] ;
1002 }
1003 E->packed = FALSE ;
1004 ok = CHOLMOD(print_sparse)(E, "E unpacked ok", cm) ; OK (ok) ;
1005
1006 ok = CHOLMOD(band_inplace)(0, 0, 0, E, cm) ; NOT (ok) ;
1007
1008 E->nz = NULL ;
1009 ok = CHOLMOD(print_sparse)(E, "E unpacked bad", cm) ; NOT (ok) ;
1010 E->nz = Enz ;
1011 ok = CHOLMOD(print_sparse)(E, "E unpacked ok", cm) ; OK (ok) ;
1012
1013 F = CHOLMOD(copy)(E, 0, 0, cm) ;
1014 cm->print = 4 ;
1015 ok = CHOLMOD(print_sparse)(F, "F pattern ok", cm) ; OK (ok) ;
1016 cm->print = 1 ;
1017
1018 CHOLMOD(free_sparse)(&F, cm) ;
1019 CHOLMOD(free_sparse)(&E, cm) ;
1020 CHOLMOD(free_sparse)(&C, cm) ;
1021
1022 /* ---------------------------------------------------------------------- */
1023 /* print_dense */
1024 /* ---------------------------------------------------------------------- */
1025
1026 X = CHOLMOD(sparse_to_dense)(NULL, cm) ; NOP (X) ;
1027 X = CHOLMOD(sparse_to_dense)(Abad2, cm) ; NOP (X) ;
1028 C = CHOLMOD(dense_to_sparse)(NULL, TRUE, cm) ; NOP (C) ;
1029
1030 X = CHOLMOD(copy_dense)(Xok, cm) ;
1031
1032 ok = CHOLMOD(print_dense)(NULL, "null", cm) ; NOT (ok) ;
1033
1034 x = X->x ;
1035 X->x = NULL ;
1036 ok = CHOLMOD(print_dense)(X, "Xnull", cm) ; NOT (ok) ;
1037 X->x = x ;
1038 ok = CHOLMOD(print_dense)(X, "X OK", cm) ; OK (ok) ;
1039
1040 X->nzmax = 1 ;
1041 ok = CHOLMOD(print_dense)(X, "X nzmax too small", cm) ; NOT (ok) ;
1042 X->nzmax = Xok->nzmax ;
1043 ok = CHOLMOD(print_dense)(X, "X OK", cm) ; OK (ok) ;
1044
1045 X->d = -1 ;
1046 ok = CHOLMOD(print_dense)(X, "X d too small", cm) ; NOT (ok) ;
1047 X->d = Xok->d ;
1048 ok = CHOLMOD(print_dense)(X, "X OK", cm) ; OK (ok) ;
1049
1050 Xxtype = X->xtype ;
1051 X->xtype = CHOLMOD_PATTERN ;
1052 ok = CHOLMOD(print_dense)(X, "X pattern", cm) ; NOT (ok) ;
1053
1054 X->xtype = -1 ;
1055 ok = CHOLMOD(print_dense)(X, "X unknown", cm) ; NOT (ok) ;
1056 X->xtype = Xxtype ;
1057 ok = CHOLMOD(print_dense)(X, "X OK", cm) ; OK (ok) ;
1058
1059 X->dtype = CHOLMOD_SINGLE ;
1060 ok = CHOLMOD(print_dense)(X, "X float", cm) ; NOT (ok) ;
1061 X->dtype = -1 ;
1062 ok = CHOLMOD(print_dense)(X, "X unknown", cm) ; NOT (ok) ;
1063 X->dtype = CHOLMOD_DOUBLE ;
1064 ok = CHOLMOD(print_dense)(X, "X OK", cm) ; OK (ok) ;
1065
1066 CHOLMOD(free_dense)(&X, cm) ;
1067
1068 /* ---------------------------------------------------------------------- */
1069 /* print_subset */
1070 /* ---------------------------------------------------------------------- */
1071
1072 ok = CHOLMOD(check_subset)(NULL, 0, 0, cm) ; OK (ok) ;
1073 ok = CHOLMOD(print_subset)(NULL, 0, 0, "null", cm) ; OK (ok) ;
1074
1075 for (i = 0 ; i < CSETSIZE ; i++)
1076 {
1077 cset [i] = i ;
1078 }
1079
1080 for (cm->print = 0 ; cm->print <= 5 ; cm->print++)
1081 {
1082 ok = CHOLMOD(print_subset)(NULL, -1, 10, "[0:9]", cm) ;
1083 OK (ok) ;
1084 ok = CHOLMOD(print_subset)(cset, CSETSIZE, CSETSIZE, "cset OK", cm) ;
1085 OK (ok) ;
1086 cset [0] = -1 ;
1087 ok = CHOLMOD(print_subset)(cset, CSETSIZE, CSETSIZE, "cset bad", cm) ;
1088 NOT (ok) ;
1089 cset [0] = CSETSIZE-1 ;
1090 ok = CHOLMOD(print_subset)(cset, CSETSIZE, CSETSIZE, "cset OK", cm) ;
1091 OK (ok) ;
1092 }
1093
1094 cm->print = 1 ;
1095
1096 /* ---------------------------------------------------------------------- */
1097 /* print_perm */
1098 /* ---------------------------------------------------------------------- */
1099
1100 ok = CHOLMOD(check_perm)(NULL, 0, 0, cm) ; OK (ok) ;
1101
1102 for (cm->print = 3 ; cm->print <= 4 ; cm->print++)
1103 {
1104 ok = CHOLMOD(print_perm)(Pok, nrow, nrow, "P OK", cm) ;
1105 OK (ok) ;
1106 if (nrow > 0)
1107 {
1108 p = Pok [0] ;
1109 Pok [0] = 2*ncol + 1 ;
1110 ok = CHOLMOD(print_perm)(Pok, nrow, nrow, "P bad", cm) ;
1111 NOT (ok) ;
1112 Pok [0] = p ;
1113 ok = CHOLMOD(print_perm)(Pok, nrow, nrow, "P OK", cm) ;
1114 }
1115 OK (ok) ;
1116 }
1117 cm->print = 1 ;
1118
1119 n2 = 2 * cm->nrow ;
1120 P2 = prand (n2) ; /* RAND */
1121
1122 for (cm->print = 3 ; cm->print <= 4 ; cm->print++)
1123 {
1124 ok = CHOLMOD(print_perm)(P2, n2, n2, "P2 OK", cm) ;
1125 OK (ok) ;
1126 p = P2 [0] ;
1127 P2 [0] = -1 ;
1128 ok = CHOLMOD(print_perm)(P2, n2, n2, "P2 bad", cm) ;
1129 NOT (ok) ;
1130 P2 [0] = p ;
1131 ok = CHOLMOD(print_perm)(P2, n2, n2, "P2 OK", cm) ;
1132 OK (ok) ;
1133 }
1134 cm->print = 1 ;
1135
1136 CHOLMOD(free)(2 * (cm->nrow), sizeof (Int), P2, cm) ;
1137
1138 /* ---------------------------------------------------------------------- */
1139 /* print_parent */
1140 /* ---------------------------------------------------------------------- */
1141
1142 ok = CHOLMOD(print_parent)(NULL, 0, "null", cm) ; NOT (ok) ;
1143 if (nrow > 0)
1144 {
1145 i = Parent [0] ;
1146 Parent [0] = -2 ;
1147 ok = CHOLMOD(print_parent)(Parent, nrow, "bad Parent", cm) ; NOT (ok) ;
1148 Parent [0] = i ;
1149 ok = CHOLMOD(print_parent)(Parent, nrow, "OK Parent", cm) ; OK (ok) ;
1150 }
1151
1152 /* ---------------------------------------------------------------------- */
1153 /* print_factor */
1154 /* ---------------------------------------------------------------------- */
1155
1156 if (A->stype == 0)
1157 {
1158 L = CHOLMOD(allocate_factor)(nrow, cm) ; OKP (L) ;
1159 ok = CHOLMOD(super_symbolic)(A, NULL, Parent, L, cm) ; NOT (ok) ;
1160 CHOLMOD(free_factor)(&L, cm) ;
1161 }
1162
1163 ok = CHOLMOD(print_factor)(NULL, "L null", cm) ; NOT (ok) ;
1164
1165 /* create a valid symbolic supernodal L */
1166 cm->supernodal = CHOLMOD_SUPERNODAL ;
1167 cm->final_asis = TRUE ;
1168 L = CHOLMOD(analyze)(A, cm) ; /* [ */ OKP (L) ;
1169 ok = CHOLMOD(print_factor)(L, "L ok", cm) ; OK (ok) ;
1170
1171 ok = CHOLMOD(change_factor)(CHOLMOD_ZOMPLEX, TRUE, TRUE, TRUE, TRUE, L, cm);
1172 NOT (ok) ;
1173
1174 OK (L->xtype == CHOLMOD_PATTERN) ;
1175 OK (L->is_super) ;
1176
1177 L->itype = CHOLMOD_INTLONG ;
1178 ok = CHOLMOD(print_factor)(L, "L int/long", cm) ; NOT (ok) ;
1179 L->itype = -1 ;
1180 ok = CHOLMOD(print_factor)(L, "L int unknown", cm) ; NOT (ok) ;
1181 L->itype = cm->itype ;
1182 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1183
1184 cm->print = 4 ;
1185 #ifdef LONG
1186 L->itype = CHOLMOD_INT ;
1187 #else
1188 L->itype = CHOLMOD_LONG ;
1189 #endif
1190 ok = CHOLMOD(print_factor)(L, "L bad itype", cm) ; NOT (ok) ;
1191 L->itype = cm->itype ;
1192 cm->print = 1 ;
1193
1194 cm->print = 4 ;
1195
1196 i = L->ordering ;
1197 L->ordering = -1 ;
1198 ok = CHOLMOD(print_factor)(L, "L bad ordering", cm) ; NOT (ok) ;
1199 L->ordering = CHOLMOD_GIVEN ;
1200 ok = CHOLMOD(print_factor)(L, "L given ordering", cm) ; OK (ok) ;
1201 L->ordering = i ;
1202
1203 Lxtype = L->xtype ;
1204 L->xtype = CHOLMOD_REAL ;
1205 ok = CHOLMOD(print_factor)(L, "L real", cm) ; NOT (ok) ;
1206 L->xtype = CHOLMOD_COMPLEX ;
1207 ok = CHOLMOD(print_factor)(L, "L complex", cm) ; NOT (ok) ;
1208 L->xtype = CHOLMOD_ZOMPLEX ;
1209 ok = CHOLMOD(print_factor)(L, "L zomplex", cm) ; NOT (ok) ;
1210 L->xtype = -1 ;
1211 ok = CHOLMOD(print_factor)(L, "L unknown", cm) ; NOT (ok) ;
1212 L->xtype = CHOLMOD_PATTERN ;
1213 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1214 L->xtype = Lxtype ;
1215
1216 /* ---------------------------------------------------------------------- */
1217 /* supernodal factor */
1218 /* ---------------------------------------------------------------------- */
1219
1220 /* create a valid supernodal numeric L (simplicial if Supernodal
1221 * module not installed) */
1222 ok = CHOLMOD(factorize)(A, L, cm) ;
1223 OK (ok || cm->status == CHOLMOD_NOT_POSDEF) ;
1224
1225 if (L->is_super)
1226 {
1227 /* there is no supernodal zomplex L */
1228 ok = CHOLMOD(factor_xtype)(CHOLMOD_ZOMPLEX, L, cm) ; NOT (ok) ;
1229 }
1230
1231 /* pack the simplicial factor, or return silently if supernodal */
1232 ok = CHOLMOD(pack_factor)(L, cm) ; OK (ok) ;
1233
1234 Lbad = CHOLMOD(copy_factor)(L, cm) ; /* [ */
1235 Lxtype = L->xtype ;
1236 Lbad->xtype = -1 ;
1237
1238 OK (L->is_super && L->xtype != CHOLMOD_PATTERN && L->is_ll) ;
1239
1240 if (A->stype == 0)
1241 {
1242 ok = CHOLMOD(super_symbolic)(A, NULL, Parent, L, cm) ; NOT (ok) ;
1243 }
1244 ok = CHOLMOD(super_symbolic)(A, Abad2, Parent, L, cm) ; NOT (ok) ;
1245 ok = CHOLMOD(super_symbolic)(Abad2, A, Parent, L, cm) ; NOT (ok) ;
1246
1247 W = CHOLMOD(zeros)(nrow, 1, L->xtype, cm) ; OKP (W) ;
1248 X = CHOLMOD(ones)(nrow, 1, L->xtype, cm) ; OKP (X) ;
1249 ok = CHOLMOD(super_lsolve)(L, X, W, cm) ; OK (ok) ;
1250 ok = CHOLMOD(super_ltsolve)(L, X, W, cm) ; OK (ok) ;
1251
1252 ok = CHOLMOD(super_lsolve)(Lbad, X, W, cm) ; NOT (ok) ;
1253 ok = CHOLMOD(super_ltsolve)(Lbad, X, W, cm) ; NOT (ok) ;
1254
1255 XX = CHOLMOD(zeros)(nrow, 1,
1256 L->xtype == CHOLMOD_REAL ? CHOLMOD_COMPLEX : CHOLMOD_REAL, cm) ;
1257 ok = CHOLMOD(super_lsolve)(L, X, XX, cm) ; NOT (ok) ;
1258 ok = CHOLMOD(super_ltsolve)(L, X, XX, cm) ; NOT (ok) ;
1259 CHOLMOD(free_dense)(&XX, cm) ;
1260
1261 ok = CHOLMOD(super_lsolve)(L, X, W, cm) ; OK (ok) ;
1262 ok = CHOLMOD(super_ltsolve)(L, X, W, cm) ; OK (ok) ;
1263
1264 x = X->x ;
1265 X->x = NULL ;
1266 ok = CHOLMOD(super_lsolve)(L, X, W, cm) ; NOT (ok) ;
1267 ok = CHOLMOD(super_ltsolve)(L, X, W, cm) ; NOT (ok) ;
1268 X->x = x ;
1269
1270 x = W->x ;
1271 W->x = NULL ;
1272 ok = CHOLMOD(super_lsolve)(L, X, W, cm) ; NOT (ok) ;
1273 ok = CHOLMOD(super_ltsolve)(L, X, W, cm) ; NOT (ok) ;
1274 W->x = x ;
1275 CHOLMOD(free_dense)(&X, cm) ;
1276 CHOLMOD(free_dense)(&W, cm) ;
1277
1278 cm->precise = TRUE ;
1279 ok = CHOLMOD(print_factor)(L, "L supernodal (precise)", cm) ; OK (ok) ;
1280 cm->precise = FALSE ;
1281 ok = CHOLMOD(print_factor)(L, "L supernodal", cm) ; OK (ok) ;
1282 cm->print = 1 ;
1283
1284 /* cannot realloc a supernodal L */
1285 ok = CHOLMOD(reallocate_factor)(10000, L, cm) ; NOT (ok) ;
1286 ok = CHOLMOD(reallocate_factor)(10000, NULL, cm) ; NOT (ok) ;
1287 ok = CHOLMOD(pack_factor)(NULL, cm) ; NOT (ok) ;
1288
1289 /* ---------------------------------------------------------------------- */
1290 /* print factor */
1291 /* ---------------------------------------------------------------------- */
1292
1293 Lxtype = L->xtype ;
1294
1295 i = cm->print ;
1296 cm->print = 4 ;
1297 L->xtype = CHOLMOD_PATTERN ;
1298 ok = CHOLMOD(print_factor)(L, "L pattern", cm) ; OK (ok) ;
1299 C = CHOLMOD(factor_to_sparse)(L, cm) ; NOP (C) ;
1300 L->xtype = Lxtype ;
1301 cm->print = i ;
1302
1303 /* check with bad L factor */
1304 ok = CHOLMOD(print_factor)(Lbad, "L unknown", cm) ; NOT (ok) ;
1305 ok = CHOLMOD(reallocate_factor)(999, Lbad, cm) ; NOT (ok) ;
1306 ok = CHOLMOD(pack_factor)(Lbad, cm) ; NOT (ok) ;
1307 C = CHOLMOD(factor_to_sparse)(Lbad, cm) ; NOP (C) ;
1308 L2 = CHOLMOD(copy_factor)(Lbad, cm) ; NOP (L2) ;
1309 ok = CHOLMOD(factorize)(A, Lbad, cm) ; NOT (ok) ;
1310 ok = CHOLMOD(resymbol)(A, NULL, 0, TRUE, Lbad, cm) ; NOT (ok) ;
1311 ok = CHOLMOD(resymbol_noperm)(A, NULL, 0, TRUE, Lbad, cm) ; NOT (ok) ;
1312 ok = CHOLMOD(rowadd)(nrow-2, A, Lbad, cm) ; NOT (ok) ;
1313 ok = CHOLMOD(rowdel)(nrow-2, NULL, Lbad, cm) ; NOT (ok) ;
1314 ok = CHOLMOD(rowfac)(A, AT, beta, 1, 2, Lbad, cm) ; NOT (ok) ;
1315 ok = CHOLMOD(updown)(+1, A, Lbad, cm) ; NOT (ok) ;
1316
1317 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1318
1319 L->dtype = CHOLMOD_SINGLE ;
1320 ok = CHOLMOD(print_factor)(L, "L float", cm) ; NOT (ok) ;
1321 L->dtype = -1 ;
1322 ok = CHOLMOD(print_factor)(L, "L unknown", cm) ; NOT (ok) ;
1323 L->dtype = CHOLMOD_DOUBLE ;
1324 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1325
1326 if (nrow > 0)
1327 {
1328 Lperm = L->Perm ;
1329 p = Lperm [0] ;
1330 Lperm [0] = -1 ;
1331 ok = CHOLMOD(print_factor)(L, "L perm invalid", cm) ; NOT (ok) ;
1332 Lperm [0] = p ;
1333 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1334 }
1335
1336 LColCount = L->ColCount ;
1337 L->ColCount = NULL ;
1338 ok = CHOLMOD(print_factor)(L, "L no colcount", cm) ; NOT (ok) ;
1339 L->ColCount = LColCount ;
1340 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1341
1342 if (nrow > 0)
1343 {
1344 LColCount = L->ColCount ;
1345 p = LColCount [0] ;
1346 LColCount [0] = -1 ;
1347 ok = CHOLMOD(print_factor)(L, "L colcount vad", cm) ; NOT (ok) ;
1348 LColCount [0] = p ;
1349 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1350 }
1351
1352 /* ---------------------------------------------------------------------- */
1353 /* print simplicial factor */
1354 /* ---------------------------------------------------------------------- */
1355
1356 /* check LDL' unpacked */
1357 ok = CHOLMOD(print_factor)(L, "L OK for L2 copy", cm) ; OK (ok) ;
1358 L2 = CHOLMOD(copy_factor)(L, cm) ; /* [ */ OKP (L2) ;
1359 ok = CHOLMOD(change_factor)(L->xtype, FALSE, FALSE, FALSE,
1360 TRUE, L2, cm) ;
1361
1362 /* check LDL' packed */
1363 L3 = CHOLMOD(copy_factor)(L, cm) ; OKP (L3) ;
1364 ok = CHOLMOD(change_factor)(L->xtype, FALSE, FALSE, TRUE,
1365 TRUE, L3, cm) ;
1366 ok = CHOLMOD(print_factor)(L3, "L3 OK", cm) ; OK (ok) ;
1367 CHOLMOD(free_factor)(&L3, cm) ; OK (ok) ;
1368 ok = CHOLMOD(print_factor)(L2, "L2 OK", cm) ; OK (ok) ;
1369 ok = CHOLMOD(pack_factor)(L2, cm) ; OK (ok) ;
1370 ok = CHOLMOD(print_factor)(L2, "L2 OK packed", cm) ; OK (ok) ;
1371
1372 /* create a simplicial factor from scratch */
1373 cm->supernodal = CHOLMOD_SIMPLICIAL ;
1374 cm->final_asis = TRUE ;
1375 L6 = CHOLMOD(analyze)(A, cm) ; /* [ */ OKP (L6) ;
1376 ok = CHOLMOD(factorize)(A, L6, cm) ;
1377 OK (cm->status >= CHOLMOD_OK) ;
1378 cm->supernodal = CHOLMOD_AUTO ;
1379
1380 ok = CHOLMOD(print_sparse)(A, "A OK", cm) ; OK (ok) ;
1381 ok = CHOLMOD(print_factor)(L6, "L6 OK", cm) ; OK (ok) ;
1382
1383 Lz = L6->z ;
1384 L6->z = NULL ;
1385 ok = CHOLMOD(print_factor)(L6, "L6 no z", cm) ;
1386 if (L6->xtype == CHOLMOD_ZOMPLEX)
1387 {
1388 NOT (ok) ;
1389 }
1390 else
1391 {
1392 OK (ok) ;
1393 }
1394 L6->z = Lz ;
1395 CHOLMOD(free_factor)(&L6, cm) ; /* ] */
1396
1397 Az = A->z ;
1398 A->z = NULL ;
1399 ok = CHOLMOD(print_sparse)(A, "A no z", cm) ;
1400 if (A->xtype == CHOLMOD_ZOMPLEX)
1401 {
1402 NOT (ok) ;
1403 }
1404 else
1405 {
1406 OK (ok) ;
1407 }
1408 A->z = Az ;
1409
1410 Lp = L2->p ;
1411 Li = L2->i ;
1412 Lx = L2->x ;
1413 Lnz = L2->nz ;
1414 Lnext = L2->next ;
1415 Lprev = L2->prev ;
1416
1417 OK (Lp [0] == 0) ;
1418
1419 L2->p = NULL ;
1420 ok = CHOLMOD(print_factor)(L2, "L no p", cm) ; NOT (ok) ;
1421 L2->p = Lp ;
1422 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1423
1424 L2->i = NULL ;
1425 ok = CHOLMOD(print_factor)(L2, "L no i", cm) ; NOT (ok) ;
1426 L2->i = Li ;
1427 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1428
1429 L2->x = NULL ;
1430 ok = CHOLMOD(print_factor)(L2, "L no x", cm) ; NOT (ok) ;
1431 L2->x = Lx ;
1432 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1433
1434 L2->nz = NULL ;
1435 ok = CHOLMOD(print_factor)(L2, "L no nz", cm) ; NOT (ok) ;
1436 L2->nz = Lnz ;
1437 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1438
1439 L2->next = NULL ;
1440 ok = CHOLMOD(print_factor)(L2, "L no next", cm) ; NOT (ok) ;
1441 L2->next = Lnext ;
1442 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1443
1444 L2->prev = NULL ;
1445 ok = CHOLMOD(print_factor)(L2, "L no prev", cm) ; NOT (ok) ;
1446 L2->prev = Lprev ;
1447 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1448
1449 if (nrow > 0)
1450 {
1451 p = Lp [0] ;
1452 Lp [0] = -1 ;
1453 ok = CHOLMOD(print_factor)(L2, "Lp bad", cm) ; NOT (ok) ;
1454 Lp [0] = p ;
1455 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1456
1457 p = Li [0] ;
1458 Li [0] = -1 ;
1459 ok = CHOLMOD(print_factor)(L2, "Li bad", cm) ; NOT (ok) ;
1460 Li [0] = p ;
1461 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1462
1463 p = Lnz [0] ;
1464 Lnz [0] = -1 ;
1465 ok = CHOLMOD(print_factor)(L2, "Lnz bad", cm) ; NOT (ok) ;
1466 Lnz [0] = p ;
1467 }
1468
1469 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1470
1471 OK (Lnz != NULL) ;
1472
1473 if (nrow > 0 && Lnz [0] > 3)
1474 {
1475 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1476 p = Li [1] ;
1477 Li [1] = nrow ;
1478 ok = CHOLMOD(print_factor)(L2, "Li bad", cm) ; NOT (ok) ;
1479 Li [1] = p ;
1480 ok = CHOLMOD(print_factor)(L2, "L OK again", cm) ; OK (ok) ;
1481
1482 p = Li [2] ;
1483 Li [2] = Li [1] ;
1484 ok = CHOLMOD(print_factor)(L2, "Li bad", cm) ; NOT (ok) ;
1485 Li [2] = p ;
1486 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1487 }
1488
1489 /* check LDL' dynamic link list */
1490 ok = CHOLMOD(change_factor)(L->xtype, FALSE, FALSE, FALSE,
1491 FALSE, L2, cm) ;
1492 OK (ok) ;
1493 ok = CHOLMOD(print_factor)(L2, "L2 OK", cm) ; OK (ok) ;
1494 OK (L2->xtype != CHOLMOD_PATTERN && !(L2->is_ll) && !(L2->is_super)) ;
1495
1496 /* cannot do a supernodal factorization on a dynamic LDL' factor */
1497 ok = CHOLMOD(super_numeric)(AT, NULL, Zero, L2, cm) ; NOT (ok) ;
1498 ok = CHOLMOD(super_numeric)(I1, NULL, Zero, L2, cm) ; NOT (ok) ;
1499 ok = CHOLMOD(super_numeric)(I1, I1, Zero, L2, cm) ; NOT (ok) ;
1500
1501 G = CHOLMOD(copy)(I1, 1, 0, cm) ; OKP (G) ;
1502 ok = CHOLMOD(super_numeric)(G, NULL, Zero, L2, cm) ; NOT (ok) ;
1503 ok = CHOLMOD(free_sparse)(&G, cm) ; OK (ok) ;
1504
1505 G = CHOLMOD(copy)(I1, -1, 0, cm) ; OKP (G) ;
1506 ok = CHOLMOD(super_numeric)(G, NULL, Zero, L2, cm) ; NOT (ok) ;
1507 ok = CHOLMOD(free_sparse)(&G, cm) ; OK (ok) ;
1508
1509 ok = CHOLMOD(super_numeric)(AT, I1, Zero, L2, cm) ; NOT (ok) ;
1510 W = CHOLMOD(zeros)(nrow, 1, CHOLMOD_REAL, cm) ; OKP (W) ;
1511 X = CHOLMOD(ones)(nrow, 1, CHOLMOD_REAL, cm) ; OKP (X) ;
1512 ok = CHOLMOD(super_lsolve)(L2, X, W, cm) ; NOT (ok) ;
1513 ok = CHOLMOD(super_ltsolve)(L2, X, W, cm) ; NOT (ok) ;
1514 ok = CHOLMOD(free_dense)(&W, cm) ; OK (ok) ;
1515 ok = CHOLMOD(free_dense)(&X, cm) ; OK (ok) ;
1516
1517 Lnext = L2->next ;
1518 Lprev = L2->prev ;
1519
1520 if (nrow > 3)
1521 {
1522
1523 p = Lnext [nrow+1] ;
1524 Lnext [nrow+1] = -1 ;
1525 ok = CHOLMOD(print_factor)(L2, "Lnext bad", cm) ; NOT (ok) ;
1526 Lnext [nrow+1] = -p ;
1527 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1528
1529 p = Lnext [2] ;
1530 Lnext [2] = 2 ;
1531 ok = CHOLMOD(print_factor)(L2, "Lnext bad", cm) ; NOT (ok) ;
1532 Lnext [2] = p ;
1533 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1534
1535 p = Lnext [2] ;
1536 Lnext [2] = -1 ;
1537 ok = CHOLMOD(print_factor)(L2, "Lnext bad", cm) ; NOT (ok) ;
1538 Lnext [2] = p ;
1539 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1540
1541 p = Lprev [2] ;
1542 Lprev [2] = -9 ;
1543 ok = CHOLMOD(print_factor)(L2, "Lprev bad", cm) ; NOT (ok) ;
1544 Lprev [2] = p ;
1545 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1546
1547 p = Lnext [nrow] ;
1548 Lnext [nrow] = 0 ;
1549 ok = CHOLMOD(print_factor)(L2, "Lnext/prev bad", cm) ; NOT (ok) ;
1550 Lnext [nrow] = p ;
1551 ok = CHOLMOD(print_factor)(L2, "L OK", cm) ; OK (ok) ;
1552
1553 /* make a non-monotonic copy of L2 and then mangle it */
1554 L6 = CHOLMOD(copy_factor)(L2, cm) ;
1555 ok = CHOLMOD(reallocate_column)(0, nrow, L6, cm) ;
1556 if (ok && !(L6->is_monotonic))
1557 {
1558 ok = CHOLMOD(print_factor)(L6, "L6 monotonic OK ", cm) ; OK (ok) ;
1559 L6->is_monotonic = TRUE ;
1560 ok = CHOLMOD(print_factor)(L6, "L6 monotonic bad", cm) ; NOT (ok) ;
1561 }
1562 CHOLMOD(free_factor)(&L6, cm) ;
1563 }
1564
1565
1566 L6 = CHOLMOD(copy_factor)(L, cm) ; OKP (L6) ;
1567 I = CHOLMOD(speye)(nrow, nrow, L->xtype, cm) ; OKP (I) ;
1568 I3 = CHOLMOD(speye)(nrow, nrow, L->xtype-1, cm) ; OKP (I3) ;
1569
1570
1571 ok = CHOLMOD(super_numeric)(I, I, beta, L6, cm) ; OK (ok) ;
1572 ok = CHOLMOD(super_numeric)(I, I3, beta, L6, cm) ; NOT (ok) ;
1573 ok = CHOLMOD(super_numeric)(I, Abad2, beta, L6, cm) ; NOT (ok) ;
1574 ok = CHOLMOD(super_numeric)(I, I, beta, Lbad, cm) ; NOT (ok) ;
1575 I->stype = -1 ;
1576 ok = CHOLMOD(super_numeric)(I, I, beta, L6, cm) ; OK (ok) ;
1577 ok = CHOLMOD(super_numeric)(I, NULL, beta, L6, cm) ; OK (ok) ;
1578 I3->stype = -1 ;
1579
1580 cm->print = 4 ;
1581 CHOLMOD(print_sparse)(I3, "I3", cm) ;
1582 CHOLMOD(print_factor)(L6, "L6", cm) ;
1583 cm->print = 1 ;
1584
1585 ok = CHOLMOD(super_numeric)(I3, NULL, beta, L6, cm) ; NOT (ok) ;
1586 CHOLMOD(free_sparse)(&I, cm) ;
1587 I = CHOLMOD(speye)(nrow+1, nrow+1, L->xtype, cm) ; OKP (I) ;
1588 I->stype = -1 ;
1589 ok = CHOLMOD(super_numeric)(I, I, beta, L6, cm) ; NOT (ok) ;
1590
1591
1592 CHOLMOD(free_sparse)(&I, cm) ;
1593 CHOLMOD(free_sparse)(&I3, cm) ;
1594 ok = CHOLMOD(free_factor)(&L6, cm) ; OK (ok) ;
1595
1596 /* check the supernodal L */
1597 Ls = L->s ;
1598 Lpi = L->pi ;
1599 Lpx = L->px ;
1600 Super = L->super ;
1601 Lx = L->x ;
1602 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1603
1604 L->s = NULL ;
1605 ok = CHOLMOD(print_factor)(L, "L no s", cm) ; NOT (ok) ;
1606 L->s = Ls ;
1607 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1608
1609 L->pi = NULL ;
1610 ok = CHOLMOD(print_factor)(L, "L no pi", cm) ; NOT (ok) ;
1611 L->pi = Lpi ;
1612 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1613
1614 L->px = NULL ;
1615 ok = CHOLMOD(print_factor)(L, "L no px", cm) ; NOT (ok) ;
1616 L->px = Lpx ;
1617 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1618
1619 L->super = NULL ;
1620 ok = CHOLMOD(print_factor)(L, "L no super", cm) ; NOT (ok) ;
1621 L->super = Super ;
1622 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1623
1624
1625 L->x = NULL ;
1626 ok = CHOLMOD(print_factor)(L, "L no x", cm) ; NOT (ok) ;
1627 L->x = Lx ;
1628 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1629
1630 p = Ls [0] ;
1631 Ls [0] = -1 ;
1632 ok = CHOLMOD(print_factor)(L, "L bad s", cm) ; NOT (ok) ;
1633 Ls [0] = p ;
1634 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1635
1636 p = Lpi [0] ;
1637 Lpi [0] = -1 ;
1638 ok = CHOLMOD(print_factor)(L, "L bad pi", cm) ; NOT (ok) ;
1639 Lpi [0] = p ;
1640 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1641
1642 p = Lpx [0] ;
1643 Lpx [0] = -1 ;
1644 ok = CHOLMOD(print_factor)(L, "L bad px", cm) ; NOT (ok) ;
1645 Lpx [0] = p ;
1646 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1647
1648 if (nrow > 0)
1649 {
1650 p = Super [0] ;
1651 Super [0] = -1 ;
1652 ok = CHOLMOD(print_factor)(L, "L bad super", cm) ; NOT (ok) ;
1653 Super [0] = p ;
1654 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1655
1656 p = Ls [0] ;
1657 Ls [0] = 42 ;
1658 ok = CHOLMOD(print_factor)(L, "L bad s", cm) ; NOT (ok) ;
1659 Ls [0] = p ;
1660 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1661 }
1662
1663 if (nrow > 0 && Lpi [1] - Lpi [0] > 3)
1664 {
1665 p = Ls [2] ;
1666 Ls [2] = Ls [1] ;
1667 ok = CHOLMOD(print_factor)(L, "L unsorted s", cm) ; NOT (ok) ;
1668 Ls [2] = p ;
1669 ok = CHOLMOD(print_factor)(L, "L OK", cm) ; OK (ok) ;
1670 }
1671
1672 /* ---------------------------------------------------------------------- */
1673 /* Cholesky */
1674 /* ---------------------------------------------------------------------- */
1675
1676 /* test the supernodal symbolic L */
1677 L3 = CHOLMOD(copy_factor)(L, cm) ; OKP (L3) ;
1678 ok = CHOLMOD(change_factor)(CHOLMOD_PATTERN, TRUE, TRUE, TRUE, TRUE,
1679 L3, cm) ;
1680 OK (ok) ;
1681
1682 Ls = L3->s ;
1683 Lpi = L3->pi ;
1684 Super = L3->super ;
1685
1686 if (nrow > 0)
1687 {
1688 p = Ls [0] ;
1689 Ls [0] = 42 ;
1690 ok = CHOLMOD(print_factor)(L3, "Lsym bad s", cm) ; NOT (ok) ;
1691 Ls [0] = p ;
1692 ok = CHOLMOD(print_factor)(L3, "Lsym OK", cm) ; OK (ok) ;
1693 }
1694
1695 if (nrow > 0 && Lpi [1] - Lpi [0] > 3)
1696 {
1697 p = Ls [2] ;
1698 Ls [2] = Ls [1] ;
1699 ok = CHOLMOD(print_factor)(L3, "Lsym unsorted s", cm) ; NOT (ok) ;
1700 Ls [2] = p ;
1701 ok = CHOLMOD(print_factor)(L3, "Lsym OK", cm) ; OK (ok) ;
1702 }
1703
1704 if (nrow > 0 && L->nsuper > 0)
1705 {
1706 Int nscol = Super [1] ;
1707 Int nsrow = Lpi [1] - Lpi [0] ;
1708 if (nsrow > nscol + 1)
1709 {
1710 p = Ls [nscol] ;
1711 Ls [nscol] = Ls [nscol+1] ;
1712 ok = CHOLMOD(print_factor)(L3, "Lsym unsorted s2", cm) ; NOT (ok) ;
1713 Ls [nscol] = p ;
1714 ok = CHOLMOD(print_factor)(L3, "Lsym OK", cm) ; OK (ok) ;
1715 }
1716 }
1717 CHOLMOD(free_factor)(&L3, cm) ;
1718
1719 /* (re)factorize as LL' */
1720 L5 = CHOLMOD(copy_factor)(L, cm) ; /* [ */ OKP (L5) ;
1721
1722 ok = CHOLMOD(factor_xtype)(-1, L, cm) ; NOT (ok) ;
1723 ok = CHOLMOD(factor_xtype)(CHOLMOD_REAL, NULL, cm) ; NOT (ok) ;
1724
1725 L3 = CHOLMOD(copy_factor)(L, cm) ; OKP (L3) ;
1726 CHOLMOD(print_factor)(L3, "L3 before factorize", cm) ;
1727 ok = CHOLMOD(change_factor)(L3->xtype, TRUE, FALSE, TRUE, TRUE, L3, cm) ;
1728 OK (ok) ;
1729
1730 Acopy = CHOLMOD(copy_sparse)(A, cm) ; /* [ */
1731 CHOLMOD(sparse_xtype)(L3->xtype, Acopy, cm) ;
1732
1733 CHOLMOD(print_sparse)(Acopy, "Acopy for factorize", cm) ;
1734
1735 ok = CHOLMOD(factorize)(Acopy, L3, cm) ;
1736 OK (ok || cm->status >= CHOLMOD_OK) ;
1737 ok = CHOLMOD(free_factor)(&L3, cm) ; OK (ok) ;
1738
1739 CHOLMOD(print_sparse)(A, "A for factorize", cm) ;
1740 CHOLMOD(print_factor)(L3, "L3 for factorize", cm) ;
1741
1742 /* refactor, but with wrong-sized A */
1743 ok = CHOLMOD(print_sparse)(I1, "I1", cm) ; OK (ok) ;
1744 ok = CHOLMOD(factorize)(I1, L, cm) ; NOT (ok) ;
1745 ok = CHOLMOD(factorize)(Abad2, L, cm) ; NOT (ok) ;
1746 C = CHOLMOD(transpose)(I1, 0, cm) ; OKP (C) ;
1747 ok = CHOLMOD(print_sparse)(C, "C = I1'", cm) ; OK (ok) ;
1748 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
1749 ok = CHOLMOD(print_factor)(L, "L OK ", cm) ; OK (ok) ;
1750
1751 /* refactor, with invalid A (NULL, or symmetric but not square) */
1752 ok = CHOLMOD(print_sparse)(Abad, "Abad", cm) ; NOT (ok) ;
1753 ok = CHOLMOD(factorize)(Abad, L, cm) ; NOT (ok) ;
1754
1755 /* refactorize supernodal LL' */
1756 printf ("refactorize here\n") ;
1757 ok = CHOLMOD(print_sparse)(Acopy, "Acopy refactorize", cm) ; OK (ok) ;
1758 ok = CHOLMOD(print_factor)(L, "L for refactorize", cm) ; OK (ok) ;
1759
1760 printf ("L->xtype for refactorize %d\n", L->xtype) ;
1761 ok = CHOLMOD(factorize)(Acopy, L, cm) ;
1762 OK (ok || cm->status == CHOLMOD_NOT_POSDEF) ;
1763 ok = CHOLMOD(print_factor)(L, "L ok, here", cm) ; OK (ok) ;
1764
1765 ok = CHOLMOD(factorize)(Acopy, L, cm) ;
1766 OK (ok || cm->status == CHOLMOD_NOT_POSDEF) ;
1767 ok = CHOLMOD(print_factor)(L, "L ok, here2", cm) ; OK (ok) ;
1768
1769 /* solve */
1770 B = CHOLMOD(ones)(nrow, 0, CHOLMOD_REAL, cm) ; OKP (B) ;
1771 X = CHOLMOD(solve)(CHOLMOD_A, L, B, cm) ; OKP (X) ;
1772 ok = CHOLMOD(free_dense)(&X, cm) ; OK (ok) ;
1773
1774 X = CHOLMOD(solve)(-1, L, B, cm) ; NOP (X) ;
1775 ok = CHOLMOD(free_dense)(&B, cm) ; OK (ok) ;
1776
1777 B = CHOLMOD(zeros)(nrow+1, 0, CHOLMOD_REAL, cm) ; OKP (B) ;
1778 X = CHOLMOD(solve)(CHOLMOD_A, L, B, cm) ; NOP (X) ;
1779
1780 B->xtype = 0 ;
1781 X = CHOLMOD(solve)(CHOLMOD_A, L, B, cm) ; NOP (X) ;
1782 B->xtype = CHOLMOD_REAL ;
1783 ok = CHOLMOD(free_dense)(&B, cm) ; OK (ok) ;
1784
1785 /* sparse solve */
1786 if (nrow < 100 && A->stype != 0)
1787 {
1788 /* solve A*C=I, so C should equal A inverse */
1789 I = CHOLMOD(speye)(nrow, nrow, CHOLMOD_REAL, cm) ; OKP (I) ;
1790 C = CHOLMOD(spsolve)(CHOLMOD_A, L, I, cm) ; OKP (C) ;
1791 /* compute norm of A*C-I */
1792 if (xtype == CHOLMOD_REAL)
1793 {
1794 E = CHOLMOD(ssmult)(A, C, 0, TRUE, FALSE, cm) ; OKP (E) ;
1795 F = CHOLMOD(add)(E, I, minusone, one, TRUE, FALSE, cm) ;OKP (F) ;
1796 cm->print = 4 ;
1797 ok = CHOLMOD(print_sparse)(F, "A*inv(A)-I", cm) ; OK (ok) ;
1798 cm->print = 1 ;
1799 r = CHOLMOD(norm_sparse)(F, 1, cm) ;
1800 OK (! (r < 0)) ;
1801 MAXERR (maxerr, r, 1) ;
1802 ok = CHOLMOD(free_sparse)(&E, cm) ; OK (ok) ;
1803 ok = CHOLMOD(free_sparse)(&F, cm) ; OK (ok) ;
1804 }
1805 CHOLMOD(free_sparse)(&C, cm) ;
1806
1807 /* check error cases for sparse solve */
1808 C = CHOLMOD(spsolve)(CHOLMOD_A, NULL, I, cm) ; NOP (C) ;
1809 C = CHOLMOD(spsolve)(CHOLMOD_A, Lbad, I, cm) ; NOP (C) ;
1810 C = CHOLMOD(spsolve)(CHOLMOD_A, L, NULL, cm) ; NOP (C) ;
1811 I->xtype = 0 ;
1812 C = CHOLMOD(spsolve)(CHOLMOD_A, L, I, cm) ; NOP (C) ;
1813 I->xtype = CHOLMOD_REAL ;
1814 I->stype = -1 ;
1815 C = CHOLMOD(spsolve)(CHOLMOD_A, L, I, cm) ; NOP (C) ;
1816 ok = CHOLMOD(free_sparse)(&I, cm) ; OK (ok) ;
1817 I = CHOLMOD(speye)(nrow+1, nrow+1, CHOLMOD_REAL, cm) ; OKP (I) ;
1818 C = CHOLMOD(spsolve)(CHOLMOD_A, L, I, cm) ; NOP (C) ;
1819 ok = CHOLMOD(free_sparse)(&I, cm) ; OK (ok) ;
1820 }
1821
1822 /* resymbol */
1823 ok = CHOLMOD(resymbol)(I1, NULL, 0, TRUE, L, cm) ; NOT (ok) ;
1824 ok = CHOLMOD(resymbol_noperm)(I1, NULL, 0, TRUE, L, cm) ; NOT (ok) ;
1825 ok = CHOLMOD(change_factor)(L->xtype, FALSE, FALSE, FALSE, FALSE, L, cm) ;
1826 OK (ok) ;
1827 ok = CHOLMOD(resymbol)(I1, NULL, 0, TRUE, L, cm) ; NOT (ok) ;
1828 ok = CHOLMOD(resymbol_noperm)(I1, NULL, 0, TRUE, L, cm) ; NOT (ok) ;
1829
1830 ok = CHOLMOD(change_factor)(-1, FALSE, FALSE, FALSE, FALSE, L, cm) ;
1831 NOT (ok) ;
1832
1833 ok = CHOLMOD(change_factor)(L->xtype, FALSE, FALSE, FALSE, FALSE, Lbad, cm);
1834 NOT (ok) ;
1835
1836 ok = CHOLMOD(resymbol_noperm)(Acopy, NULL, 0, TRUE, L2, cm) ;
1837 if (Acopy->stype <= 0)
1838 {
1839 OK (ok) ;
1840 }
1841 else
1842 {
1843 NOT (ok) ;
1844 }
1845
1846 ok = CHOLMOD(resymbol_noperm)(Abad2, NULL, 0, TRUE, L2, cm) ; NOT (ok) ;
1847 ok = CHOLMOD(resymbol)(Abad2, NULL, 0, TRUE, L2, cm) ; NOT (ok) ;
1848
1849 ok = CHOLMOD(resymbol_noperm)(Acopy, NULL, 0, TRUE, NULL, cm) ; NOT (ok) ;
1850 ok = CHOLMOD(resymbol)(Acopy, NULL, 0, TRUE, L2, cm) ; OK (ok) ;
1851
1852 if (ncol > 0)
1853 {
1854 ok = CHOLMOD(print_perm)(fsetbad, ncol, ncol, "bad fset", cm) ;
1855 NOT (ok) ;
1856 }
1857
1858 if (ncol > 1)
1859 {
1860 ok = CHOLMOD(resymbol)(Acopy, fsetok, ncol/2, TRUE, L2, cm) ; OK (ok) ;
1861 ok = CHOLMOD(resymbol)(Acopy, fsetbad, ncol/2, TRUE, L2, cm) ;
1862 if (Acopy->stype)
1863 {
1864 /* fset is ignored */
1865 OK (ok) ;
1866 }
1867 else
1868 {
1869 NOT (ok) ;
1870 ok = CHOLMOD(resymbol_noperm)(Acopy, fsetbad, ncol/2, TRUE, L2, cm);
1871 NOT (ok) ;
1872 }
1873 Acopy->sorted = FALSE ;
1874 ok = CHOLMOD(resymbol)(Acopy, fsetok, ncol/2, TRUE, L2, cm) ;
1875 OK (ok) ;
1876 Acopy->sorted = TRUE ;
1877 }
1878
1879 cm->print = 4 ;
1880 gsave0 = cm->grow0 ;
1881 gsave1 = cm->grow1 ;
1882 gsave2 = cm->grow2 ;
1883
1884 /* reallocate column */
1885 L4 = NULL ;
1886 if (nrow > 0)
1887 {
1888 ok = CHOLMOD(print_factor)(L, "L ok, for colrealloc", cm) ; OK (ok) ;
1889 L4 = CHOLMOD(copy_factor)(L, cm) ;
1890 ok = CHOLMOD(print_factor)(L4, "L4 ok, for colrealloc", cm) ; OK (ok) ;
1891 OK (nrow == (Int)(L->n)) ;
1892 ok = CHOLMOD(reallocate_column)(nrow, 1, L4, cm) ; NOT (ok) ;
1893 ok = CHOLMOD(reallocate_column)(nrow-1, 0, L4, cm) ; NOT (ok) ;
1894 ok = CHOLMOD(reallocate_column)(nrow-1, 10, L4, cm) ; OK (ok) ;
1895
1896 cm->grow0 = 2e10 ;
1897 cm->grow1 = 2 ;
1898
1899 /* this may or may not fail */
1900 ok = CHOLMOD(reallocate_column)(0, 10, L4, cm) ;
1901 CHOLMOD(print_common)("OK or too large", cm) ;
1902 ok = CHOLMOD(free_factor)(&L4, cm) ; OK (ok) ;
1903 }
1904
1905 cm->grow0 = gsave0 ;
1906 cm->grow1 = gsave1 ;
1907 cm->grow2 = gsave2 ;
1908
1909 if (ok && nrow > 2)
1910 {
1911 L4 = CHOLMOD(copy_factor)(L, cm) ;
1912 ok = CHOLMOD(resymbol)(A, NULL, 0, TRUE, L4, cm) ; OK (ok) ;
1913
1914 /* make it non-monotonic and then monotonic (LDL' unpacked) */
1915 ok = CHOLMOD(reallocate_column)(0, nrow-1, L4, cm) ; OK (ok) ;
1916
1917 /* this should be OK for small matrices, but fail for large ones */
1918 cm->grow0 = nrow ;
1919 cm->grow1 = nrow ;
1920 cm->grow2 = nrow ;
1921 ok = CHOLMOD(change_factor)(CHOLMOD_REAL, FALSE, FALSE, FALSE, TRUE,
1922 L4, cm) ;
1923
1924 ok = CHOLMOD(free_factor)(&L4, cm) ; OK (ok) ;
1925 L4 = CHOLMOD(copy_factor)(L, cm) ;
1926 ok = CHOLMOD(resymbol)(A, NULL, 0, TRUE, L4, cm) ; OK (ok) ;
1927 ok = CHOLMOD(pack_factor)(L4, cm) ; OK (ok) ;
1928
1929 /* now try to make L4 really huge */
1930
1931 /*
1932 cm->print = 5 ;
1933 CHOLMOD(print_sparse) (A, "A for huge", cm) ;
1934 CHOLMOD(print_factor) (L4, "L4 for huge", cm) ;
1935 */
1936
1937 if (ok && !(L->is_super) && L->xtype != CHOLMOD_PATTERN)
1938 {
1939
1940 cm->grow0 = gsave0 ;
1941 cm->grow1 = gsave1 ;
1942 cm->grow2 = gsave2 ;
1943
1944 ok = CHOLMOD(reallocate_column)(0, nrow-1, L4, cm) ; OK (ok) ;
1945
1946 cm->grow0 = nrow ;
1947 cm->grow1 = nrow ;
1948 cm->grow2 = nrow ;
1949
1950 /*
1951 CHOLMOD(print_factor) (L4, "L4 for huge, realloced", cm) ;
1952 printf ("L4 for huge is monotonic: %d\n", L4->is_monotonic) ;
1953 */
1954
1955 if (!(L4->is_monotonic))
1956 {
1957 /* printf ("Make L4 really huge: ") ; */
1958 ok = CHOLMOD(change_factor)(CHOLMOD_REAL, TRUE, FALSE, FALSE,
1959 TRUE, L4, cm) ;
1960 printf ("L4 huge ok: "ID"\n", ok) ;
1961 }
1962 }
1963 ok = CHOLMOD(free_factor)(&L4, cm) ; OK (ok) ;
1964 }
1965
1966 cm->grow0 = gsave0 ;
1967 cm->grow1 = gsave1 ;
1968 cm->grow2 = gsave2 ;
1969
1970 cm->print = 1 ;
1971
1972 /* ---------------------------------------------------------------------- */
1973 /* more error tests */
1974 /* ---------------------------------------------------------------------- */
1975
1976 cm->error_handler = NULL ;
1977
1978 /* ---------------------------------------------------------------------- */
1979 /* modify */
1980 /* ---------------------------------------------------------------------- */
1981
1982 X = CHOLMOD(ones)(nrow, 1, CHOLMOD_REAL, cm) ; OKP (X) ;
1983 R = CHOLMOD(dense_to_sparse)(X, TRUE, cm) ; /* [ */
1984 OKP (R) ;
1985
1986 if (isreal)
1987 {
1988 C = CHOLMOD(speye)(nrow, 1, CHOLMOD_REAL, cm) ; OKP (C) ;
1989 ok = CHOLMOD(updown)(+1, C, L, cm) ; OK (ok) ;
1990 X1 = CHOLMOD(ones)(nrow, 1, CHOLMOD_REAL, cm) ;
1991 B1 = CHOLMOD(eye)(nrow, 1, CHOLMOD_REAL, cm) ;
1992 ok = CHOLMOD(updown_solve)(+1, C, L, X1, B1, cm) ; OK (ok) ;
1993 B1->xtype = -999 ;
1994 ok = CHOLMOD(updown_solve)(+1, C, L, X1, B1, cm) ; NOT (ok) ;
1995 ok = CHOLMOD(rowadd_solve)(0, R, beta, L, X1, B1, cm) ; NOT (ok) ;
1996 ok = CHOLMOD(rowdel_solve)(0, R, beta, L, X1, B1, cm) ; NOT (ok) ;
1997 B1->xtype = CHOLMOD_REAL ;
1998 CHOLMOD(free_dense)(&B1, cm) ;
1999 B2 = CHOLMOD(ones)(nrow, 2, CHOLMOD_REAL, cm) ;
2000 ok = CHOLMOD(updown_solve)(+1, C, L, X1, B2, cm) ; NOT (ok) ;
2001 ok = CHOLMOD(rowadd_solve)(0, R, beta, L, X1, B2, cm) ; NOT (ok) ;
2002 ok = CHOLMOD(rowdel_solve)(0, R, beta, L, X1, B2, cm) ; NOT (ok) ;
2003
2004 CHOLMOD(free_dense)(&B2, cm) ;
2005 CHOLMOD(free_dense)(&X1, cm) ;
2006 ok = CHOLMOD(updown)(+1, Abad2, L, cm) ; NOT (ok) ;
2007
2008 ok = CHOLMOD(updown)(+1, C, NULL, cm) ; NOT (ok) ;
2009
2010 C->sorted = FALSE ;
2011 ok = CHOLMOD(updown)(+1, C, L, cm) ; NOT (ok) ;
2012 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
2013
2014 ok = CHOLMOD(updown)(+1, NULL, L, cm) ; NOT (ok) ;
2015
2016 if (nrow > 0)
2017 {
2018 C = CHOLMOD(speye)(nrow-1, 1, CHOLMOD_REAL, cm) ; OKP (C) ;
2019 ok = CHOLMOD(updown)(+1, C, L, cm) ; NOT (ok) ;
2020 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
2021 }
2022
2023 C = CHOLMOD(speye)(nrow, 0, CHOLMOD_REAL, cm) ; OKP (C) ;
2024 ok = CHOLMOD(updown)(+1, C, L, cm) ; OK (ok) ;
2025
2026 ok = CHOLMOD(rowdel)(0, C, L, cm) ; NOT (ok) ;
2027 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
2028 }
2029
2030 /* ---------------------------------------------------------------------- */
2031 /* rowfac, rcond */
2032 /* ---------------------------------------------------------------------- */
2033
2034 cm->nmethods = 1 ;
2035 cm->method [0].ordering = CHOLMOD_NATURAL ;
2036 cm->postorder = FALSE ;
2037
2038 cm->print = 5 ;
2039 cm->final_ll = TRUE ;
2040 for (xtype2 = CHOLMOD_REAL ; xtype2 <= CHOLMOD_ZOMPLEX ; xtype2++)
2041 {
2042 cm->supernodal = CHOLMOD_SIMPLICIAL ;
2043
2044 /* factor a singular matrix (C=LL') */
2045 printf ("start singular LL'\n") ;
2046 XX = CHOLMOD(ones)(4, 4, xtype2, cm) ; OKP (X) ;
2047 C = CHOLMOD(dense_to_sparse)(XX, TRUE, cm) ; OKP (C) ;
2048 CHOLMOD(free_dense)(&XX, cm) ;
2049 C->stype = 1 ;
2050 CHOLMOD(print_sparse)(C, "C ones", cm) ;
2051 L6 = CHOLMOD(analyze)(C, cm) ; OKP (L6) ;
2052 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2053 printf ("status %d\n", cm->status) ;
2054 ok1 = (cm->status == CHOLMOD_NOT_POSDEF) ;
2055 ok = CHOLMOD(print_factor)(L6, "L6 singular", cm) ; OK (ok) ;
2056 OK (ok1) ;
2057 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond == 0) ;
2058
2059 /* now make C positive definite */
2060 CHOLMOD(free_sparse)(&C, cm) ;
2061 XX = CHOLMOD(ones)(4, 4, xtype2, cm) ; OKP (X) ;
2062 x = XX->x ;
2063 for (i = 0 ; i < 4 ; i++)
2064 {
2065 if (xtype2 == CHOLMOD_REAL || xtype2 == CHOLMOD_ZOMPLEX)
2066 {
2067 x [i + 4*i] = 42 ;
2068 }
2069 else /* complex */
2070 {
2071 x [2*(i + 4*i)] = 42 ;
2072 }
2073 }
2074 C = CHOLMOD(dense_to_sparse)(XX, TRUE, cm) ; OKP (C) ;
2075 CHOLMOD(free_dense)(&XX, cm) ;
2076 C->stype = 1 ;
2077 CHOLMOD(print_sparse)(C, "C ok", cm) ;
2078 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2079 ok1 = (cm->status == CHOLMOD_OK) ;
2080 ok = CHOLMOD(print_factor)(L6, "L6 ok", cm) ; OK (ok) ;
2081 OK (ok1) ;
2082 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond > 0) ;
2083
2084 /* generate intentional nan's, to test the nan-handling of cholmod_rcond */
2085 if (do_nantests)
2086 {
2087
2088 xnan = xnan/xnan ;
2089
2090 /* C(2,2) = nan */
2091 x = C->x ;
2092 i = 2 ;
2093 if (xtype2 == CHOLMOD_REAL || xtype2 == CHOLMOD_ZOMPLEX)
2094 {
2095 x [i + 4*i] = xnan ;
2096 }
2097 else /* complex */
2098 {
2099 x [2*(i + 4*i)] = xnan ;
2100 }
2101 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2102 ok1 = (cm->status == CHOLMOD_OK) ;
2103 ok = CHOLMOD(print_factor)(L6, "L6 nan2", cm) ; OK (ok) ;
2104 printf ("rcond %g\n", rcond) ;
2105 OK (ok1) ;
2106 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond == 0) ;
2107 CHOLMOD(free_factor)(&L6, cm) ;
2108
2109 /* C(2,2) = nan, LDL' */
2110 cm->supernodal = CHOLMOD_SIMPLICIAL ;
2111 cm->final_ll = TRUE ;
2112 L6 = CHOLMOD(analyze)(C, cm) ; OKP (L6) ;
2113 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2114 ok1 = (cm->status == CHOLMOD_OK) ;
2115 ok = CHOLMOD(print_factor)(L6, "LDL6 nan2", cm) ; OK (ok) ;
2116 OK (ok1) ;
2117 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond == 0) ;
2118 CHOLMOD(free_factor)(&L6, cm) ;
2119
2120 /* C(2,2) = nan, supernodal */
2121 cm->supernodal = CHOLMOD_SUPERNODAL ;
2122 cm->final_ll = FALSE ;
2123 L6 = CHOLMOD(analyze)(C, cm) ; OKP (L6) ;
2124 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2125 /* sometimes LAPACK says NaN is not pos.def, sometimes it doesn't...*/
2126 ok1 = (cm->status == CHOLMOD_OK || cm->status == CHOLMOD_NOT_POSDEF) ;
2127 ok = CHOLMOD(print_factor)(L6, "L6 supernan2", cm) ; OK (ok) ;
2128 OK (ok1) ;
2129 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond == 0) ;
2130 CHOLMOD(free_factor)(&L6, cm) ;
2131
2132 /* C(0,0) = nan */
2133 cm->supernodal = CHOLMOD_SIMPLICIAL ;
2134 cm->final_ll = FALSE ;
2135 x [0] = xnan ;
2136 L6 = CHOLMOD(analyze)(C, cm) ; OKP (L6) ;
2137 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2138 ok1 = (cm->status == CHOLMOD_OK) ;
2139 ok = CHOLMOD(print_factor)(L6, "L6 nan0", cm) ; OK (ok) ;
2140 OK (ok1) ;
2141 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond == 0) ;
2142 CHOLMOD(free_factor)(&L6, cm) ;
2143
2144 /* C(0,0) = nan, LDL' */
2145 cm->supernodal = CHOLMOD_SIMPLICIAL ;
2146 cm->final_ll = TRUE ;
2147 L6 = CHOLMOD(analyze)(C, cm) ; OKP (L6) ;
2148 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2149 ok1 = (cm->status == CHOLMOD_OK) ;
2150 ok = CHOLMOD(print_factor)(L6, "LDL6 nan0", cm) ; OK (ok) ;
2151 OK (ok1) ;
2152 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond == 0) ;
2153 CHOLMOD(free_factor)(&L6, cm) ;
2154
2155 /* C(0,0) = nan, supernodal */
2156 cm->supernodal = CHOLMOD_SUPERNODAL ;
2157 cm->final_ll = FALSE ;
2158 L6 = CHOLMOD(analyze)(C, cm) ; OKP (L6) ;
2159 ok = CHOLMOD(factorize)(C, L6, cm) ; OK (ok) ;
2160 /* sometimes LAPACK says NaN is not pos.def, sometimes it doesn't...*/
2161 ok1 = (cm->status == CHOLMOD_OK || cm->status == CHOLMOD_NOT_POSDEF) ;
2162 ok = CHOLMOD(print_factor)(L6, "L6 supernan0", cm) ; OK (ok) ;
2163 OK (ok1) ;
2164 rcond = CHOLMOD(rcond) (L6, cm) ; OK (rcond == 0) ;
2165 }
2166
2167 CHOLMOD(free_factor)(&L6, cm) ;
2168 CHOLMOD(free_sparse)(&C, cm) ;
2169 }
2170 cm->supernodal = CHOLMOD_AUTO ;
2171 cm->final_ll = FALSE ;
2172 cm->print = 1 ;
2173
2174 /* ---------------------------------------------------------------------- */
2175 /* refactorize simplicial LDL' */
2176 /* ---------------------------------------------------------------------- */
2177
2178 if (nrow < NLARGE)
2179 {
2180 L7 = CHOLMOD(analyze) (A, cm) ; OKP (L7) ;
2181 ok = CHOLMOD(factorize) (A, L7, cm) ; OK (ok) ;
2182 ok = CHOLMOD(factorize) (A, L7, cm) ; OK (ok) ;
2183 B7 = CHOLMOD(ones) (nrow, 1, xtype, cm) ; OKP (B7) ;
2184 X7 = CHOLMOD(solve) (CHOLMOD_A, L7, B7, cm) ; OKP (X7) ;
2185 ok = CHOLMOD(free_dense) (&X7, cm) ; OK (ok) ;
2186 ok = CHOLMOD(free_dense) (&B7, cm) ; OK (ok) ;
2187 if (A->stype > 0)
2188 {
2189 ok = CHOLMOD(rowfac) (A, NULL, zero, 0, nrow, L7, cm) ; OK (ok) ;
2190 ok = CHOLMOD(rowfac) (A, NULL, zero, 0, nrow, L7, cm) ; OK (ok) ;
2191 printf ("I7 :::\n") ;
2192 I7 = CHOLMOD(speye) (nrow+1, 1, xtype, cm) ; OKP (I7) ;
2193 I7->stype = 1 ;
2194 ok = CHOLMOD(rowfac) (I7,NULL, zero, 0, nrow, L7, cm) ; NOT(ok) ;
2195 printf ("I7 ::: done\n") ;
2196 CHOLMOD(free_sparse) (&I7, cm) ;
2197 }
2198 ok = CHOLMOD(free_factor) (&L7, cm) ; OK (ok) ;
2199 }
2200
2201 cm->nmethods = 0 ; /* restore defaults */
2202 cm->method [0].ordering = CHOLMOD_GIVEN ;
2203 cm->postorder = TRUE ;
2204
2205 /* ---------------------------------------------------------------------- */
2206 /* row subtree */
2207 /* ---------------------------------------------------------------------- */
2208
2209 i = nrow / 2 ;
2210
2211 C = CHOLMOD(allocate_sparse)(nrow, 1, nrow, TRUE, TRUE, 0,
2212 CHOLMOD_REAL, cm) ; OKP (C) ;
2213 C2 = CHOLMOD(allocate_sparse)(nrow, 1, nrow, TRUE, TRUE, 0,
2214 CHOLMOD_REAL, cm) ; OKP (C) ;
2215 ok = CHOLMOD(row_subtree)(NULL, NULL, i, Parent, C, cm) ; NOT (ok) ;
2216 ok = CHOLMOD(row_lsubtree)(NULL, NULL, 0, i, L, C2, cm) ; NOT (ok) ;
2217
2218 if (A->stype == 0 && nrow > 0 && AT != NULL)
2219 {
2220 ok = CHOLMOD(row_subtree)(A, AT, i, Parent, C, cm) ; OK (ok) ;
2221
2222 ATp = AT->p ;
2223 ATi = AT->i ;
2224 fnz = ATp [i+1] - ATp [i] ;
2225 ok = CHOLMOD(row_lsubtree)(A, ATi, fnz, i, L, C2, cm) ;
2226 /*
2227 if (i < ncol) { OK (ok) ; } else { NOT (ok) ; }
2228 */
2229 OK (ok) ;
2230
2231 ok = CHOLMOD(row_lsubtree)(Abad2, ATi, fnz, i, L, C2, cm) ; NOT (ok) ;
2232 ok = CHOLMOD(row_lsubtree)(A, NULL, fnz, i, L, C2, cm) ; NOT (ok) ;
2233 ok = CHOLMOD(row_lsubtree)(A, ATi, fnz, i, L, Abad2, cm) ; NOT (ok) ;
2234 ok = CHOLMOD(row_lsubtree)(A, ATi, fnz, i, NULL, C2, cm) ; NOT (ok) ;
2235 ok = CHOLMOD(row_lsubtree)(A, ATi, fnz, nrow+1, L, C2, cm) ;NOT (ok) ;
2236
2237 ok = CHOLMOD(row_subtree)(Abad2, AT, i, Parent, C, cm) ; NOT (ok) ;
2238 ok = CHOLMOD(row_subtree)(A, Abad2, i, Parent, C, cm) ; NOT (ok) ;
2239 ok = CHOLMOD(row_subtree)(A, AT, i, Parent, Abad2, cm) ; NOT (ok) ;
2240 ok = CHOLMOD(row_subtree)(A, NULL, i, Parent, C, cm) ; NOT (ok) ;
2241 ok = CHOLMOD(row_subtree)(A, AT, nrow+1, Parent, C, cm) ; NOT (ok) ;
2242 }
2243 else
2244 {
2245 ok = CHOLMOD(row_subtree)(A, NULL, i, Parent, C, cm) ;
2246 if (A->stype == 1 && nrow > 0)
2247 {
2248 OK (ok) ;
2249 }
2250 else
2251 {
2252 NOT (ok) ;
2253 }
2254 #if 0
2255 ok = CHOLMOD(row_lsubtree)(A, NULL, 0, i, L, C2, cm) ;
2256 printf ("%g %g %g\n", (double) A->stype, (double) nrow, (double) ok) ;
2257 if (A->stype == 1 && nrow > 0 || (A->stype == 0 && nrow == 0 &&
2258 A->ncol == 1))
2259 {
2260 OK (ok) ;
2261 }
2262 else
2263 {
2264 NOT (ok) ;
2265 }
2266 #endif
2267 }
2268
2269 ok = CHOLMOD(row_subtree)(A, NULL, i, Parent, NULL, cm) ; NOT (ok) ;
2270 ok = CHOLMOD(row_subtree)(A, NULL, i, NULL, C, cm) ; NOT (ok) ;
2271 ok = CHOLMOD(row_lsubtree)(A, NULL, 0, i, L, NULL, cm) ; NOT (ok) ;
2272
2273 if (A->stype == 1 && nrow > 0)
2274 {
2275 /* add extra entries in the (ignored) lower triangular part to AA */
2276 if (!(A->sorted))
2277 {
2278 ok = CHOLMOD(sort)(A, cm) ; OK (ok) ;
2279 }
2280 AA = CHOLMOD(copy)(A, 0, 0, cm) ;
2281 OK (AA->sorted) ;
2282 AA->stype = 1 ;
2283 ok = CHOLMOD(row_subtree)(AA, NULL, i, Parent, C, cm) ; OK (ok) ;
2284 ok = CHOLMOD(row_lsubtree)(AA, NULL, 0, i, L, C2, cm) ; OK (ok) ;
2285 ok = CHOLMOD(free_sparse)(&AA, cm) ; OK (ok) ;
2286 }
2287
2288 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
2289 ok = CHOLMOD(free_sparse)(&C2, cm) ; OK (ok) ;
2290
2291 C = CHOLMOD(speye)(nrow, 0, CHOLMOD_REAL, cm) ; OKP (C) ;
2292 if (A->stype == 0 && AT != NULL && nrow > 0)
2293 {
2294 ok = CHOLMOD(row_subtree)(A, AT, i, Parent, C, cm) ; NOT (ok) ;
2295
2296 ATp = AT->p ;
2297 ATi = AT->i ;
2298 fnz = ATp [i+1] - ATp [i] ;
2299 ok = CHOLMOD(row_lsubtree)(A, ATi, fnz, i, L, C, cm) ; NOT (ok) ;
2300 }
2301 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
2302
2303 L6 = CHOLMOD(allocate_factor)(nrow, cm) ; OKP (L6) ;
2304 if (A->stype == 0 && nrow > 2)
2305 {
2306 ok = CHOLMOD(rowfac)(A, AT, beta, 0, 1, L6, cm) ; OK (ok) ;
2307 OK (cm->status == CHOLMOD_OK) ;
2308 ok = CHOLMOD(rowfac)(A, NULL, beta, 1, 2, L6, cm) ; NOT (ok) ;
2309 ok = CHOLMOD(rowfac)(A, AT, beta, 1, 2, L6, cm) ; OK (ok) ;
2310 ok = CHOLMOD(rowfac)(Abad2, AT, beta, 1, 2, L6, cm) ; NOT (ok) ;
2311 ok = CHOLMOD(rowfac)(A, Abad2, beta, 1, 2, L6, cm) ; NOT (ok) ;
2312 }
2313 ok = CHOLMOD(free_factor)(&L6, cm) ; OK (ok) ;
2314
2315 /* ---------------------------------------------------------------------- */
2316 /* horzcat, vertcat */
2317 /* ---------------------------------------------------------------------- */
2318
2319 if (A->nrow != A->ncol)
2320 {
2321 C = CHOLMOD(horzcat)(A, AT, TRUE, cm) ; NOP (C) ;
2322 C = CHOLMOD(vertcat)(A, AT, TRUE, cm) ; NOP (C) ;
2323 }
2324 C = CHOLMOD(horzcat)(A, Axbad, TRUE, cm) ; NOP (C) ;
2325 C = CHOLMOD(vertcat)(A, Axbad, TRUE, cm) ; NOP (C) ;
2326 C = CHOLMOD(vertcat)(A, NULL, TRUE, cm) ; NOP (C) ;
2327 C = CHOLMOD(vertcat)(NULL, AT, TRUE, cm) ; NOP (C) ;
2328 C = CHOLMOD(horzcat)(A, NULL, TRUE, cm) ; NOP (C) ;
2329 C = CHOLMOD(horzcat)(NULL, AT, TRUE, cm) ; NOP (C) ;
2330
2331 /* ---------------------------------------------------------------------- */
2332 /* print_triplet */
2333 /* ---------------------------------------------------------------------- */
2334
2335 cm->print = 4 ;
2336 ok = CHOLMOD(print_triplet)(Tok, "T ok", cm) ; OK (ok) ;
2337 T = CHOLMOD(copy_triplet)(Tok, cm) ; /* [ */ OKP (T) ;
2338
2339 Tz = T->z ;
2340 T->z = NULL ;
2341 ok = CHOLMOD(print_triplet)(T, "T no z", cm) ;
2342 if (T->xtype == CHOLMOD_ZOMPLEX)
2343 {
2344 NOT (ok) ;
2345 }
2346 else
2347 {
2348 OK (ok) ;
2349 }
2350 T->z = Tz ;
2351 cm->print = 1 ;
2352
2353 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2354
2355 ok = CHOLMOD(print_triplet)(NULL, "null", cm) ; NOT (ok) ;
2356
2357 p = T->nzmax ;
2358 T->nzmax = T->nnz - 1 ;
2359 ok = CHOLMOD(print_triplet)(T, "T nzmax too small", cm) ; NOT (ok) ;
2360 T->nzmax = p ;
2361 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2362
2363 T->itype = -1 ;
2364 ok = CHOLMOD(print_triplet)(T, "T itype bad", cm) ; NOT (ok) ;
2365 T->itype = CHOLMOD_INTLONG ;
2366 ok = CHOLMOD(print_triplet)(T, "T itype bad", cm) ; NOT (ok) ;
2367 T->itype = cm->itype ;
2368 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2369
2370 cm->print = 4 ;
2371 #ifdef LONG
2372 T->itype = CHOLMOD_INT ;
2373 #else
2374 T->itype = CHOLMOD_LONG ;
2375 #endif
2376 ok = CHOLMOD(print_triplet)(T, "T bad itype", cm) ; NOT (ok) ;
2377 T->itype = cm->itype ;
2378 cm->print = 1 ;
2379
2380 Txtype = T->xtype ;
2381 T->xtype = -1 ;
2382 ok = CHOLMOD(print_triplet)(T, "T xtype bad", cm) ; NOT (ok) ;
2383
2384 T->xtype = Txtype ;
2385 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2386
2387 T->dtype = -1 ;
2388 ok = CHOLMOD(print_triplet)(T, "T dtype bad", cm) ; NOT (ok) ;
2389 T->dtype = CHOLMOD_SINGLE ;
2390 ok = CHOLMOD(print_triplet)(T, "T dtype bad", cm) ; NOT (ok) ;
2391 T->dtype = CHOLMOD_DOUBLE ;
2392 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2393
2394 Tj = T->j ;
2395 Ti = T->i ;
2396 Tx = T->x ;
2397
2398 T->j = NULL ;
2399 ok = CHOLMOD(print_triplet)(T, "Tj null", cm) ; NOT (ok) ;
2400 T->j = Tj ;
2401 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2402
2403 T->i = NULL ;
2404 ok = CHOLMOD(print_triplet)(T, "Ti null", cm) ; NOT (ok) ;
2405 T->i = Ti ;
2406 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2407
2408 T->x = NULL ;
2409 ok = CHOLMOD(print_triplet)(T, "Tx null", cm) ; NOT (ok) ;
2410 T->x = Tx ;
2411 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2412
2413 if (T->nnz > 0)
2414 {
2415 p = Ti [0] ;
2416 Ti [0] = -1 ;
2417 ok = CHOLMOD(print_triplet)(T, "Ti bad", cm) ; NOT (ok) ;
2418 C = CHOLMOD(triplet_to_sparse)(T, 0, cm) ; NOP (C) ;
2419 Ti [0] = p ;
2420 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2421
2422 p = Tj [0] ;
2423 Tj [0] = -1 ;
2424 ok = CHOLMOD(print_triplet)(T, "Tj bad", cm) ; NOT (ok) ;
2425 C = CHOLMOD(triplet_to_sparse)(T, 0, cm) ; NOP (C) ;
2426 Tj [0] = p ;
2427 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2428 }
2429
2430 cm->print = 4 ;
2431 CHOLMOD(triplet_xtype)(CHOLMOD_PATTERN, T, cm) ;
2432 ok = CHOLMOD(print_triplet)(T, "T pattern ok", cm) ; OK (ok) ;
2433 cm->print = 1 ;
2434
2435 /* ---------------------------------------------------------------------- */
2436 /* triplet, realloc_multiple */
2437 /* ---------------------------------------------------------------------- */
2438
2439 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2440 OK (cm->status == CHOLMOD_OK) ;
2441
2442 cm->print = 4 ;
2443 if (T->nrow != T->ncol)
2444 {
2445 OK (T->stype == 0) ;
2446
2447 CHOLMOD(print_triplet)(T, "T ok", cm) ;
2448
2449 C = CHOLMOD(triplet_to_sparse)(T, 0, cm) ;
2450 CHOLMOD(print_sparse)(C, "C ok", cm) ;
2451 OKP (C) ;
2452 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
2453
2454 Ti = T->i ;
2455 T->i = NULL ;
2456 C = CHOLMOD(triplet_to_sparse)(T, 0, cm) ; NOP (C) ;
2457 T->i = Ti ;
2458
2459 Tj = T->j ;
2460 T->j = NULL ;
2461 C = CHOLMOD(triplet_to_sparse)(T, 0, cm) ; NOP (C) ;
2462 T->j = Tj ;
2463
2464 T->stype = 1 ;
2465 ok = CHOLMOD(print_triplet)(T, "T bad", cm) ; NOT (ok) ;
2466 C = CHOLMOD(triplet_to_sparse)(T, 0, cm) ; NOP (C) ;
2467 T->stype = 0 ;
2468 ok = CHOLMOD(print_triplet)(T, "T pattern ok", cm) ; OK (ok) ;
2469 }
2470 OK (cm->status == CHOLMOD_OK) ;
2471 cm->print = 1 ;
2472
2473 ok = CHOLMOD(reallocate_triplet)(1, NULL, cm) ; NOT (ok) ;
2474
2475 CHOLMOD(print_triplet)(T, "T before realloc", cm) ;
2476 ok = CHOLMOD(reallocate_triplet)(1+(T->nzmax), T, cm) ; OK (ok) ;
2477 CHOLMOD(print_triplet)(T, "T after realloc", cm) ;
2478
2479 nznew = 10 + T->nzmax ;
2480 pp = NULL ;
2481
2482 ok = CHOLMOD(realloc_multiple)(Size_max/2, 2, T->xtype, &(T->i),
2483 &(T->j), &(T->x), &(T->z), &(T->nzmax), cm) ; NOT (ok) ;
2484
2485 size = 0 ;
2486 ii = NULL ;
2487 jj = NULL ;
2488 xx = NULL ;
2489 ok = CHOLMOD(realloc_multiple)(Size_max, 2, CHOLMOD_REAL, &ii, &jj, &xx,
2490 NULL, &size, cm) ; NOT (ok) ;
2491
2492 ok = CHOLMOD(realloc_multiple)(0, 0, CHOLMOD_PATTERN, &ii, &jj, &xx, NULL,
2493 &size, cm) ; OK (ok) ;
2494
2495 ok = CHOLMOD(realloc_multiple)(0, 0, -1, &ii, &jj, &xx, NULL,
2496 &size, cm) ; NOT (ok) ;
2497
2498 /* change to pattern-only */
2499 CHOLMOD(triplet_xtype)(CHOLMOD_PATTERN, T, cm) ;
2500
2501 ok = CHOLMOD(reallocate_triplet)(1+(T->nzmax), T, cm) ; OK (ok) ;
2502
2503 ok = CHOLMOD(free_triplet)(&T, cm) ; /* ] */ OK (ok) ;
2504
2505 T = CHOLMOD(allocate_triplet)(nrow, ncol, Size_max, 0, CHOLMOD_REAL, cm);
2506 NOP (T) ;
2507
2508 T2 = CHOLMOD(allocate_triplet)(4, 4, 8, 0, CHOLMOD_REAL, cm); OKP (T2) ;
2509 ok = CHOLMOD(reallocate_triplet)(12, T2, cm) ; OK (ok) ;
2510 T = CHOLMOD(copy_triplet)(T2, cm) ; OKP (T) ;
2511 CHOLMOD(free_triplet)(&T, cm) ;
2512 T = CHOLMOD(sparse_to_triplet)(A, cm) ; OKP (T) ;
2513 C = CHOLMOD(triplet_to_sparse)(T, 100, cm) ; OKP (C) ;
2514 CHOLMOD(free_sparse)(&C, cm) ;
2515 CHOLMOD(free_triplet)(&T, cm) ;
2516
2517 T2->xtype = -1 ;
2518 ok = CHOLMOD(reallocate_triplet)(16, T2, cm) ; NOT (ok) ;
2519 T = CHOLMOD(copy_triplet)(T2, cm) ; NOP (T) ;
2520 C = CHOLMOD(triplet_to_sparse)(T2, 100, cm) ; NOP (C) ;
2521 T2->xtype = CHOLMOD_REAL ;
2522 CHOLMOD(free_triplet)(&T2, cm) ;
2523
2524 T = CHOLMOD(allocate_triplet)(4, 4, 16, 0, -1, cm); NOP (T) ;
2525
2526 T = CHOLMOD(sparse_to_triplet)(Abad2, cm) ; NOP (T) ;
2527
2528 for (stype = -1 ; stype <= 1 ; stype++)
2529 {
2530 T = CHOLMOD(allocate_triplet)(4, 4, 16, stype, CHOLMOD_PATTERN, cm) ;
2531 OKP (T) ;
2532 Ti = T->i ;
2533 Tj = T->j ;
2534 k = 0 ;
2535 for (i = 0 ; i < 4 ; i++)
2536 {
2537 for (j = 0 ; j < 4 ; j++)
2538 {
2539 Ti [k] = i ;
2540 Tj [k] = j ;
2541 k++ ;
2542 }
2543 }
2544 T->nnz = k ;
2545 C = CHOLMOD(triplet_to_sparse)(T, 0, cm) ;
2546 cm->print = 4 ;
2547 printf ("stype "ID"\n", stype) ;
2548 CHOLMOD(print_triplet)(T, "T from triplet", cm) ;
2549 CHOLMOD(print_sparse)(C, "C from triplet", cm) ;
2550 cm->print = 1 ;
2551 OKP (C) ;
2552 CHOLMOD(free_sparse)(&C, cm) ;
2553 CHOLMOD(free_triplet)(&T, cm) ;
2554 }
2555
2556 /* ---------------------------------------------------------------------- */
2557 /* sparse_to_triplet */
2558 /* ---------------------------------------------------------------------- */
2559
2560 if (A->nrow != A->ncol)
2561 {
2562 OK (A->stype == 0) ;
2563 T = CHOLMOD(sparse_to_triplet)(A, cm) ; OKP (T) ;
2564 ok = CHOLMOD(print_triplet)(T, "T ok", cm) ; OK (ok) ;
2565
2566 T2 = CHOLMOD(copy_triplet)(NULL, cm) ; NOP (T2) ;
2567
2568 Ti = T->i ;
2569 T->i = NULL ;
2570 T2 = CHOLMOD(copy_triplet)(T, cm) ; NOP (T2) ;
2571 T->i = Ti ;
2572
2573 Tj = T->j ;
2574 T->j = NULL ;
2575 T2 = CHOLMOD(copy_triplet)(T, cm) ; NOP (T2) ;
2576 T->j = Tj ;
2577
2578 ok = CHOLMOD(free_triplet)(&T, cm) ; OK (ok) ;
2579 A->stype = 1 ;
2580 T = CHOLMOD(sparse_to_triplet)(A, cm) ; NOP (T) ;
2581 A->stype = 0 ;
2582 T = CHOLMOD(sparse_to_triplet)(NULL, cm) ; NOP (T) ;
2583 }
2584
2585 /* ---------------------------------------------------------------------- */
2586 /* colamd */
2587 /* ---------------------------------------------------------------------- */
2588
2589 ok = CHOLMOD(colamd)(A, fsetok, fsizeok, TRUE, NULL, cm) ; NOT (ok) ;
2590 ok = CHOLMOD(colamd)(NULL, fsetok, fsizeok, TRUE, Pok, cm) ; NOT (ok) ;
2591
2592 cm->current = 0 ;
2593
2594 save1 = cm->method [0].prune_dense2 ;
2595 save2 = cm->method [0].ordering ;
2596 save4 = cm->nmethods ;
2597
2598 cm->method [0].prune_dense2 = 0.5 ;
2599 cm->method [0].ordering = CHOLMOD_COLAMD ;
2600 cm->nmethods = 1 ;
2601
2602 ok = CHOLMOD(colamd)(A, fsetok, fsizeok, TRUE, Pok, cm) ;
2603 if (A->stype == 0)
2604 {
2605 save3 = cm->print ;
2606 cm->print = 5 ;
2607 ok = CHOLMOD(print_common) ("colamd dense2", cm) ; OK (ok) ;
2608 cm->print = save3 ;
2609 OK (ok) ;
2610 }
2611 else
2612 {
2613 NOT (ok) ;
2614 }
2615
2616 cm->method [0].prune_dense2 = save1 ;
2617 cm->method [0].ordering = save2 ;
2618 cm->nmethods = save4 ;
2619
2620 cm->current = -1 ;
2621 ok = CHOLMOD(colamd)(A, fsetok, fsizeok, TRUE, Pok, cm) ;
2622 if (A->stype == 0)
2623 {
2624 OK (ok) ;
2625 }
2626 else
2627 {
2628 NOT (ok) ;
2629 }
2630 cm->current = 0 ;
2631
2632 ok = CHOLMOD(colamd)(Abad2, NULL, 0, TRUE, Pok, cm) ; NOT (ok) ;
2633
2634 if (ncol > 0)
2635 {
2636 ok = CHOLMOD(colamd)(A, fsetbad, ncol, TRUE, Pok, cm) ; NOT (ok) ;
2637 }
2638
2639 /* mangle the matrix to test integer overflow in colamd */
2640 if (A->stype == 0)
2641 {
2642 nzmax = A->nzmax ;
2643 A->nzmax = Size_max/2 ;
2644 ok = CHOLMOD(colamd)(A, fsetok, fsizeok, TRUE, Pok, cm) ; NOT (ok) ;
2645 A->nzmax = nzmax ;
2646 }
2647
2648 /* ---------------------------------------------------------------------- */
2649 /* ccolamd/csymamd */
2650 /* ---------------------------------------------------------------------- */
2651
2652 #ifndef NCAMD
2653 ok = CHOLMOD(ccolamd)(A, fsetok, fsizeok, NULL, NULL, cm) ; NOT (ok) ;
2654 ok = CHOLMOD(ccolamd)(A, fsetok, fsizeok, NULL, Pok, cm) ;
2655 if (A->stype == 0)
2656 {
2657 OK (ok) ;
2658 }
2659 else
2660 {
2661 NOT (ok) ;
2662 }
2663 ok = CHOLMOD(ccolamd)(Abad2, NULL, 0, NULL, Pok, cm) ; NOT (ok) ;
2664
2665 ok = CHOLMOD(csymamd)(A, NULL, Pok, cm) ;
2666 if (A->nrow == A->ncol)
2667 {
2668 OK (ok) ;
2669 }
2670 else
2671 {
2672 NOT (ok) ;
2673 }
2674 ok = CHOLMOD(csymamd)(Abad2, NULL, Pok, cm) ; NOT (ok) ;
2675 ok = CHOLMOD(csymamd)(NULL, NULL, Pok, cm) ; NOT (ok) ;
2676 ok = CHOLMOD(csymamd)(A, NULL, NULL, cm) ; NOT (ok) ;
2677
2678 /* mangle the matrix to test integer overflow in colamd */
2679 if (A->stype == 0)
2680 {
2681 nzmax = A->nzmax ;
2682 A->nzmax = Size_max/2 ;
2683 ok = CHOLMOD(ccolamd)(A, fsetok, fsizeok, NULL, Pok, cm) ; NOT (ok) ;
2684 A->nzmax = nzmax ;
2685 }
2686 #endif
2687
2688 /* ---------------------------------------------------------------------- */
2689 /* amd */
2690 /* ---------------------------------------------------------------------- */
2691
2692 ok = CHOLMOD(amd)(A, NULL, 0, Pok, cm) ; OK (ok) ;
2693
2694 /* ---------------------------------------------------------------------- */
2695 /* metis */
2696 /* ---------------------------------------------------------------------- */
2697
2698 #ifndef NPARTITION
2699 /* no METIS memory guard */
2700 cm->metis_memory = 0 ;
2701 if (A->stype)
2702 {
2703 E = CHOLMOD(copy)(A, 0, -1, cm) ;
2704 }
2705 else
2706 {
2707 E = CHOLMOD(aat)(A, NULL, 0, -1, cm) ;
2708 }
2709 enz = CHOLMOD(nnz)(E, cm) ;
2710
2711 CHOLMOD(print_sparse)(A, "A for metis", cm) ;
2712
2713 if (A != NULL && Pok != NULL)
2714 {
2715 ok = CHOLMOD(metis)(A, NULL, 0, TRUE, Pok, cm) ;
2716
2717 /* memory guard triggered */
2718 if (nrow > 0)
2719 {
2720 double density ;
2721
2722 cm->metis_memory = Size_max ;
2723 ok = CHOLMOD(metis)(A, NULL, 0, FALSE, Pok, cm) ;
2724 OK (ok) ;
2725 /* Pok should be identity */
2726 for (j = 0 ; j < nrow ; j++)
2727 {
2728 OK (Pok [j] == j) ;
2729 }
2730
2731 /* memory guard triggered */
2732 cm->metis_memory = 2 ;
2733 cm->metis_nswitch = 10 ;
2734
2735
2736 ok = CHOLMOD(metis)(A, NULL, 0, FALSE, Pok, cm) ; OK (ok) ;
2737 /* Pok should be identity if the matrix is dense */
2738 density = ((double) enz) / (((double) nrow) * ((double) nrow)) ;
2739 if (nrow > 10 && density > cm->metis_dswitch)
2740 {
2741 for (j = 0 ; j < nrow ; j++)
2742 {
2743 OK (Pok [j] == j) ;
2744 }
2745 }
2746 }
2747 }
2748
2749 /* restore METIS default memory guard */
2750 cm->metis_memory = 2 ;
2751 cm->metis_nswitch = 3000 ;
2752
2753 /* check metis bisector error handling */
2754 if (E != NULL && enz > 0)
2755 {
2756 Int *Anw, *Aew ;
2757 Anw = CHOLMOD(malloc)(nrow, sizeof (Int), cm) ;
2758 Aew = CHOLMOD(malloc)(MAX (anz,enz), sizeof (Int), cm) ;
2759 for (j = 0 ; j < nrow ; j++)
2760 {
2761 Anw [j] = 1 ;
2762 }
2763 for (j = 0 ; j < enz ; j++)
2764 {
2765 Aew [j] = 1 ;
2766 }
2767 lr = CHOLMOD(metis_bisector)(E, Anw, Aew, Pok, cm) ;
2768 if (E->stype || E->nrow != E->ncol)
2769 {
2770 NOT (lr >= 0) ;
2771 }
2772 else
2773 {
2774 OK (lr >= 0) ;
2775 }
2776 lr = CHOLMOD(metis_bisector)(Abad2, Anw, Aew, Pok, cm) ;NOT (lr >= 0);
2777 lr = CHOLMOD(metis_bisector)(NULL, Anw, Aew, Pok, cm) ; NOT (lr >= 0);
2778 lr = CHOLMOD(metis_bisector)(A, Anw, Aew, NULL, cm) ; NOT (lr >= 0);
2779
2780 if (A->stype)
2781 {
2782 lr = CHOLMOD(metis_bisector)(A, Anw, Aew, Pok, cm) ; NOT (lr>=0) ;
2783 }
2784
2785 CHOLMOD(free)(nrow, sizeof (Int), Anw, cm) ;
2786 CHOLMOD(free)(MAX (anz,enz), sizeof (Int), Aew, cm) ;
2787 }
2788
2789 CHOLMOD(free_sparse)(&E, cm) ;
2790
2791 CHOLMOD(print_sparse)(Abad, "Abad", cm) ;
2792 lr = CHOLMOD(bisect)(Abad, NULL, 0, TRUE, Partition, cm) ;
2793 if (Abad != NULL && Abad->nrow == 0)
2794 {
2795 OK (lr == 0) ;
2796 }
2797 else
2798 {
2799 NOT (lr >= 0) ;
2800 }
2801
2802 lr = CHOLMOD(bisect)(A, NULL, 0, TRUE, NULL, cm) ; NOT (lr >= 0);
2803 lr = CHOLMOD(bisect)(NULL, NULL, 0, TRUE, Partition, cm) ; NOT (lr >= 0);
2804
2805 lr = CHOLMOD(nested_dissection)(NULL, NULL, 0, Pok, CParent,
2806 Cmember, cm) ; NOT (lr>=0) ;
2807
2808 lr = CHOLMOD(nested_dissection)(A, NULL, 0, NULL, CParent,
2809 Cmember, cm) ; NOT (lr>=0) ;
2810
2811 lr = CHOLMOD(nested_dissection)(A, NULL, 0, Pok, NULL,
2812 Cmember, cm) ; NOT (lr>=0) ;
2813
2814 lr = CHOLMOD(nested_dissection)(A, NULL, 0, Pok, CParent,
2815 NULL, cm) ; NOT (lr>=0) ;
2816
2817 ok = CHOLMOD(metis)(NULL, NULL, 0, TRUE, Pok, cm) ; NOT (ok) ;
2818 ok = CHOLMOD(metis)(A, NULL, 0, TRUE, NULL, cm) ; NOT (ok) ;
2819 ok = CHOLMOD(metis)(Abad2, NULL, 0, FALSE, Pok, cm) ; NOT (ok) ;
2820 lr = CHOLMOD(bisect)(Abad2, NULL, 0, TRUE, Partition, cm) ; NOT (lr >= 0);
2821 #endif
2822
2823 /* ---------------------------------------------------------------------- */
2824 /* etree */
2825 /* ---------------------------------------------------------------------- */
2826
2827 if (A->stype < 0)
2828 {
2829 ok = CHOLMOD(etree)(A, Parent, cm) ; NOT (ok) ;
2830 }
2831 ok = CHOLMOD(etree)(Abad2, Parent, cm) ; NOT (ok) ;
2832
2833 /* ---------------------------------------------------------------------- */
2834 /* etree, postorder, rowcolcount */
2835 /* ---------------------------------------------------------------------- */
2836
2837 if (A->stype == 0 && ncol > 0)
2838 {
2839 AFT = CHOLMOD(ptranspose)(A, 1, NULL, fsetok, fsizeok, cm) ; OKP(AFT);
2840 AF = CHOLMOD(transpose)(AFT, 1, cm) ; OKP(AF);
2841
2842 ok = CHOLMOD(etree)(NULL, Parent, cm) ; NOT(ok);
2843 ok = CHOLMOD(etree)(AFT, NULL, cm) ; NOT(ok);
2844 ok = CHOLMOD(etree)(AFT, Parent, cm) ; OK (ok);
2845
2846 lr = CHOLMOD(postorder)(Parent, nrow, NULL, Post, cm) ; OK (lr>=0) ;
2847 lr = CHOLMOD(postorder)(NULL, nrow, NULL, Post, cm) ; NOT (lr>=0) ;
2848 lr = CHOLMOD(postorder)(Parent, nrow, NULL, NULL, cm) ; NOT (lr>=0) ;
2849
2850
2851 ok = CHOLMOD(rowcolcounts)(A, fsetok, fsizeok, Parent,
2852 Post, NULL, ColCount, First, Level, cm) ; OK (ok);
2853
2854 ok = CHOLMOD(rowcolcounts)(Abad2, fsetok, fsizeok, Parent,
2855 Post, NULL, ColCount, First, Level, cm) ; NOT(ok);
2856
2857 ok = CHOLMOD(rowcolcounts)(NULL, fsetok, fsizeok, Parent,
2858 Post, NULL, ColCount, First, Level, cm) ; NOT(ok);
2859 ok = CHOLMOD(rowcolcounts)(A, fsetok, fsizeok, NULL,
2860 Post, NULL, ColCount, First, Level, cm) ; NOT(ok);
2861 ok = CHOLMOD(rowcolcounts)(A, fsetok, fsizeok, Parent,
2862 NULL, NULL, ColCount, First, Level, cm) ; NOT(ok);
2863 ok = CHOLMOD(rowcolcounts)(A, fsetok, fsizeok, Parent,
2864 Post, NULL, NULL, First, Level, cm) ; NOT(ok);
2865 ok = CHOLMOD(rowcolcounts)(A, fsetok, fsizeok, Parent,
2866 Post, NULL, ColCount, NULL, Level, cm) ; NOT(ok);
2867 ok = CHOLMOD(rowcolcounts)(A, fsetok, fsizeok, Parent,
2868 Post, NULL, ColCount, First, NULL, cm) ; NOT(ok);
2869
2870 ok = CHOLMOD(rowcolcounts)(A, fsetbad, ncol, Parent,
2871 Post, NULL, ColCount, First, Level, cm) ; NOT(ok);
2872 ok = CHOLMOD(rowcolcounts)(A, fsetok, fsizeok, Parent,
2873 Post, NULL, ColCount, First, NULL, cm) ; NOT(ok);
2874
2875 CHOLMOD(free_sparse)(&AF, cm) ;
2876 CHOLMOD(free_sparse)(&AFT, cm) ;
2877 }
2878
2879 /* ---------------------------------------------------------------------- */
2880 /* norm */
2881 /* ---------------------------------------------------------------------- */
2882
2883 nm = CHOLMOD(norm_sparse)(A, 2, cm) ; NOT (nm>=0) ;
2884 nm = CHOLMOD(norm_sparse)(Abad, 0, cm) ; NOT (nm>=0) ;
2885 nm = CHOLMOD(norm_sparse)(Abad2, 2, cm) ; NOT (nm>=0) ;
2886 nm = CHOLMOD(norm_dense)(Bok, 3, cm) ; NOT (nm>=0) ;
2887 nm = CHOLMOD(norm_dense)(Bok, 2, cm) ; NOT (nm>=0) ;
2888 nm = CHOLMOD(norm_dense)(Xbad2, 1, cm) ; NOT (nm>=0) ;
2889
2890 /* ---------------------------------------------------------------------- */
2891 /* copy dense */
2892 /* ---------------------------------------------------------------------- */
2893
2894 ok = CHOLMOD(copy_dense2)(NULL, Bok, cm) ; NOT (ok) ;
2895 ok = CHOLMOD(copy_dense2)(Bok, NULL, cm) ; NOT (ok) ;
2896
2897 ok = CHOLMOD(copy_dense2)(Bok, Xbad2, cm) ; NOT (ok) ;
2898 ok = CHOLMOD(copy_dense2)(Xbad2, Xbad2, cm) ; NOT (ok) ;
2899
2900 if (nrow > 1)
2901 {
2902
2903 /* wrong dimensions */
2904 ok = CHOLMOD(copy_dense2)(Two, Bok, cm) ; NOT (ok) ;
2905
2906 /* mangled matrix */
2907 Y = CHOLMOD(copy_dense)(Bok, cm) ; OKP (Y) ;
2908 Y->d = 0 ;
2909 ok = CHOLMOD(copy_dense2)(Bok, Y, cm) ; NOT (ok) ;
2910 CHOLMOD(free_dense)(&Y, cm) ;
2911
2912 Y = CHOLMOD(copy_dense)(Xbad2, cm) ; NOP (Y) ;
2913 Y = CHOLMOD(copy_dense)(NULL, cm) ; NOP (Y) ;
2914 }
2915
2916 /* ---------------------------------------------------------------------- */
2917 /* complex */
2918 /* ---------------------------------------------------------------------- */
2919
2920 W = CHOLMOD(eye)(4, 4, CHOLMOD_COMPLEX, cm) ; OKP (W) ;
2921 ok = CHOLMOD(dense_xtype)(0, W, cm) ; NOT (ok) ;
2922 ok = CHOLMOD(dense_xtype)(CHOLMOD_REAL, W, cm) ; OK (ok) ;
2923 ok = CHOLMOD(dense_xtype)(CHOLMOD_REAL, NULL, cm) ; NOT (ok) ;
2924 k = W->xtype ;
2925 W->xtype = -1 ;
2926 ok = CHOLMOD(dense_xtype)(CHOLMOD_REAL, W, cm) ; NOT (ok) ;
2927 W->xtype = k ;
2928 ok = CHOLMOD(free_dense)(&W, cm) ; OK (ok) ;
2929
2930 C = CHOLMOD(speye)(4, 4, CHOLMOD_COMPLEX, cm) ; OKP (C) ;
2931 ok = CHOLMOD(sparse_xtype)(-1, C, cm) ; NOT (ok) ;
2932 ok = CHOLMOD(sparse_xtype)(CHOLMOD_ZOMPLEX, C, cm) ; OK (ok) ;
2933 ok = CHOLMOD(sparse_xtype)(CHOLMOD_ZOMPLEX, NULL, cm) ; NOT (ok) ;
2934 T = CHOLMOD(sparse_to_triplet)(C, cm) ; OKP (T) ;
2935 ok = CHOLMOD(triplet_xtype)(-1, T, cm) ; NOT (ok) ;
2936 ok = CHOLMOD(triplet_xtype)(CHOLMOD_ZOMPLEX, T, cm) ; OK (ok) ;
2937 ok = CHOLMOD(triplet_xtype)(CHOLMOD_ZOMPLEX, NULL, cm) ; NOT (ok) ;
2938
2939 k = T->xtype ;
2940 T->xtype = -1 ;
2941 ok = CHOLMOD(triplet_xtype)(CHOLMOD_REAL, T, cm) ; NOT (ok) ;
2942 T->xtype = k ;
2943
2944 k = C->xtype ;
2945 C->xtype = -1 ;
2946 ok = CHOLMOD(sparse_xtype)(CHOLMOD_REAL, C, cm) ; NOT (ok) ;
2947 C->xtype = k ;
2948
2949 ok = CHOLMOD(free_triplet)(&T, cm) ; OK (ok) ;
2950 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
2951
2952 ok = CHOLMOD(factor_xtype)(CHOLMOD_REAL, Lbad, cm) ; NOT (ok) ;
2953
2954 /* ---------------------------------------------------------------------- */
2955 /* rowadd */
2956 /* ---------------------------------------------------------------------- */
2957
2958 x = X->x ;
2959 X->x = NULL ;
2960 C = CHOLMOD(dense_to_sparse)(X, TRUE, cm) ; NOP (C) ;
2961
2962 if (nrow > 3 && isreal)
2963 {
2964 ok = CHOLMOD(rowadd)(1, I1, L, cm) ; NOT (ok) ;
2965 ok = CHOLMOD(rowadd)(nrow+1, R, L, cm) ; NOT (ok) ;
2966 ok = CHOLMOD(rowadd)(nrow+1, R, L, cm) ; NOT (ok) ;
2967 ok = CHOLMOD(rowdel)(nrow+1, NULL, L5, cm) ; NOT (ok) ;
2968
2969 ok = CHOLMOD(rowdel)(nrow-2, NULL, L5, cm) ; OK (ok) ;
2970 ok = CHOLMOD(rowdel)(nrow-2, NULL, L5, cm) ; OK (ok) ;
2971 ok = CHOLMOD(rowdel)(nrow-2, Abad2, L5, cm) ; NOT (ok) ;
2972 ok = CHOLMOD(rowdel)(nrow-1, R, L5, cm) ; NOT (ok) ;
2973
2974 ok = CHOLMOD(change_factor)(CHOLMOD_REAL, TRUE, FALSE, TRUE, TRUE, L5,
2975 cm) ;
2976 OK (ok) ;
2977
2978 ok = CHOLMOD(rowadd)(nrow-2, NULL, L5, cm) ; NOT (ok) ;
2979 ok = CHOLMOD(rowadd)(nrow-2, R, NULL, cm) ; NOT (ok) ;
2980
2981 ok = CHOLMOD(rowadd)(nrow-2, R, L5, cm) ; OK (ok) ;
2982
2983 ok = CHOLMOD(rowadd)(nrow-2, Abad2, L5, cm) ; NOT (ok) ;
2984
2985 /* ok = CHOLMOD(rowadd)(nrow-2, R, L5, cm) ; NOT (ok) ; */
2986 ok = CHOLMOD(rowdel)(nrow-2, NULL, L5, cm) ; OK (ok) ;
2987 ok = CHOLMOD(change_factor)(CHOLMOD_PATTERN, TRUE,
2988 TRUE, TRUE, TRUE, L5, cm) ; NOT (ok) ;
2989 ok = CHOLMOD(change_factor)(CHOLMOD_REAL, TRUE,
2990 TRUE, TRUE, TRUE, L5, cm) ; NOT (ok) ;
2991
2992 ok = CHOLMOD(rowadd_solve)(nrow-2, R, beta, L5, X, X, cm) ; NOT (ok) ;
2993 ok = CHOLMOD(rowdel_solve)(nrow-2, R, beta, L5, X, X, cm) ; NOT (ok) ;
2994 ok = CHOLMOD(updown_solve)(TRUE, R, L5, X, X, cm) ; NOT (ok) ;
2995
2996 if (nrow < 200 && L5 != NULL && R2 != NULL)
2997 {
2998 cholmod_factor *L8 ;
2999 Int *L8p, *L8i, *L8nz, rnz ;
3000 double *L8x ;
3001 L8 = CHOLMOD(copy_factor) (L5, cm) ;
3002 ok = TRUE ;
3003 for (k = nrow-1 ; ok && L8 != NULL
3004 && L8->xtype == CHOLMOD_REAL && k >= 0 ; k--)
3005 {
3006 for (rnz = 0 ; rnz < nrow ; rnz++)
3007 {
3008 /* first, ensure row i is zero */
3009 for (j = 0 ; j < nrow ; j++)
3010 {
3011 L8p = L8->p ;
3012 L8i = L8->i ;
3013 L8nz = L8->nz ;
3014 L8x = L8->x ;
3015 for (p = L8p [j] ; p < L8p [j] + L8nz [j] ; p++)
3016 {
3017 i = L8i [p] ;
3018 if (i == k) L8x [p] = 0 ;
3019 }
3020 }
3021 R2p [1] = rnz ;
3022 ok = CHOLMOD(rowadd)(k, R2, L8, cm) ; OK (ok) ;
3023 ok = CHOLMOD(rowdel)(k, NULL, L8, cm) ; OK (ok) ;
3024 ok = CHOLMOD(rowadd)(k, R2, L8, cm) ; OK (ok) ;
3025 }
3026 }
3027 CHOLMOD(free_factor) (&L8, cm) ;
3028 }
3029 }
3030
3031 X->x = x ;
3032 ok = CHOLMOD(free_dense)(&X, cm) ; OK (ok) ;
3033
3034 /* ---------------------------------------------------------------------- */
3035 /* ssmult */
3036 /* ---------------------------------------------------------------------- */
3037
3038 if (nrow < 100)
3039 {
3040 C = CHOLMOD(ssmult)(A, A, 0, TRUE, TRUE, cm) ;
3041 if (A->nrow != A->ncol || !isreal)
3042 {
3043 NOP (C) ;
3044 }
3045 else
3046 {
3047 OKP (C) ;
3048 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
3049 }
3050 C = CHOLMOD(ssmult)(NULL, A, 0, TRUE, TRUE, cm) ; NOP (C) ;
3051 C = CHOLMOD(ssmult)(A, NULL, 0, TRUE, TRUE, cm) ; NOP (C) ;
3052 C = CHOLMOD(ssmult)(A, Axbad, 0, TRUE, TRUE, cm) ; NOP (C) ;
3053 }
3054
3055 /* ---------------------------------------------------------------------- */
3056 /* sdmult */
3057 /* ---------------------------------------------------------------------- */
3058
3059 if (nrow > 1)
3060 {
3061 ok = CHOLMOD(sdmult)(A, FALSE, one, one, Two, Two, cm) ; NOT (ok) ;
3062 }
3063
3064 YY = CHOLMOD(ones)(A->nrow, 1, xtype, cm) ; OKP (YY) ;
3065 XX = CHOLMOD(ones)(A->ncol, 1, xtype, cm) ; OKP (XX) ;
3066 cm->print = 4 ;
3067 ok = CHOLMOD(print_dense)(XX, "XX", cm) ; OK (ok) ;
3068 cm->print = 1 ;
3069 ok = CHOLMOD(sdmult)(A, FALSE, one, one, XX, YY, cm) ; OK (ok) ;
3070 ok = CHOLMOD(sdmult)(NULL, FALSE, one, one, XX, YY, cm) ; NOT (ok) ;
3071 ok = CHOLMOD(sdmult)(A, FALSE, one, one, NULL, YY, cm) ; NOT (ok) ;
3072 ok = CHOLMOD(sdmult)(A, FALSE, one, one, XX, NULL, cm) ; NOT (ok) ;
3073
3074 ok = CHOLMOD(sdmult)(Abad2, FALSE, one, one, XX, YY, cm) ; NOT (ok) ;
3075
3076 XX->xtype++ ;
3077 ok = CHOLMOD(sdmult)(A, FALSE, one, one, XX, YY, cm) ; NOT (ok) ;
3078 XX->xtype-- ;
3079
3080 YY->xtype++ ;
3081 ok = CHOLMOD(sdmult)(A, FALSE, one, one, XX, YY, cm) ; NOT (ok) ;
3082 YY->xtype-- ;
3083
3084 CHOLMOD(free_dense)(&YY, cm) ;
3085 CHOLMOD(free_dense)(&XX, cm) ;
3086
3087 /* ---------------------------------------------------------------------- */
3088 /* symmetry */
3089 /* ---------------------------------------------------------------------- */
3090
3091 for (option = 0 ; option <= 2 ; option++)
3092 {
3093 Int xmatched = 0, pmatched = 0, nzoffdiag = 0, nz_diag = 0 ;
3094 int asym ;
3095 printf ("test symmetry: option %d\n", option) ;
3096 save1 = cm->print ;
3097 cm->print = 5 ;
3098 CHOLMOD(print_sparse) (A, "A", cm) ;
3099 cm->print = save1 ;
3100 asym = CHOLMOD(symmetry) (A, option, &xmatched, &pmatched,
3101 &nzoffdiag, &nz_diag, cm) ;
3102 printf ("asym: %d\n", asym) ;
3103 OK (A->stype != 0 || asym >= 0) ;
3104 save1 = A->xtype ;
3105 A->xtype = CHOLMOD_PATTERN ;
3106 asym = CHOLMOD(symmetry) (A, option, &xmatched, &pmatched,
3107 &nzoffdiag, &nz_diag, cm) ;
3108 printf ("asym: %d pattern\n", asym) ;
3109 OK (A->stype != 0 || asym >= 0) ;
3110 A->xtype = save1 ;
3111 C = CHOLMOD(copy_sparse) (A, cm) ;
3112 OKP (C) ;
3113 ok = CHOLMOD(sparse_xtype) (CHOLMOD_ZOMPLEX, C, cm) ;
3114 OK (ok) ;
3115 asym = CHOLMOD(symmetry) (C, option, &xmatched, &pmatched,
3116 &nzoffdiag, &nz_diag, cm) ;
3117 OK (A->stype != 0 || asym >= 0) ;
3118 printf ("asym: %d zomplex\n", asym) ;
3119
3120 asym = CHOLMOD(symmetry) (NULL, option, &xmatched, &pmatched,
3121 &nzoffdiag, &nz_diag, cm) ;
3122 NOT (asym >= 0) ;
3123
3124 C->xtype = 999 ;
3125 asym = CHOLMOD(symmetry) (C, option, &xmatched, &pmatched,
3126 &nzoffdiag, &nz_diag, cm) ;
3127 NOT (asym >= 0) ;
3128 C->xtype = CHOLMOD_ZOMPLEX ;
3129
3130 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
3131
3132 C = CHOLMOD(copy) (A, 0, (A->xtype == CHOLMOD_REAL), cm) ;
3133 OKP (C) ;
3134 asym = CHOLMOD(symmetry) (C, option, &xmatched, &pmatched,
3135 &nzoffdiag, &nz_diag, cm) ;
3136 OK (asym >= 0) ;
3137 ok = CHOLMOD(free_sparse)(&C, cm) ; OK (ok) ;
3138 }
3139
3140 /* ---------------------------------------------------------------------- */
3141 /* memory tests */
3142 /* ---------------------------------------------------------------------- */
3143
3144 R3 = CHOLMOD(speye)(nrow, 1, CHOLMOD_PATTERN, cm) ; /* [ */
3145 OKP (R3) ;
3146
3147 test_memory_handler ( ) ;
3148
3149 ok = CHOLMOD(amd)(A, NULL, 0, Pok, cm) ;
3150 if (A->nrow == 0)
3151 {
3152 OK (ok) ;
3153 }
3154 else
3155 {
3156 NOT (ok) ;
3157 }
3158
3159 #ifndef NCAMD
3160 ok = CHOLMOD(camd)(A, NULL, 0, NULL, Pok, cm) ;
3161 if (A->nrow == 0)
3162 {
3163 OK (ok) ;
3164 }
3165 else
3166 {
3167 NOT (ok) ;
3168 }
3169 #endif
3170
3171 C = CHOLMOD(aat)(A, NULL, 0, 0, cm) ; NOP (C) ;
3172 A->sorted = FALSE ;
3173 ok = CHOLMOD(check_sparse)(A, cm) ; NOT (ok) ;
3174 A->sorted = TRUE ;
3175
3176 CHOLMOD(free_work)(cm) ;
3177 if (A->stype == 0)
3178 {
3179 for (trial = 0 ; !ok && trial < 20 ; trial++)
3180 {
3181 my_tries = trial ;
3182 printf ("--------------------- trial "ID"\n", my_tries) ;
3183 ok = CHOLMOD(colamd)(A, NULL, 0, TRUE, Pok, cm) ;
3184 }
3185 OK (ok) ;
3186 }
3187
3188
3189 #ifndef NCAMD
3190 test_memory_handler ( ) ;
3191 ok = CHOLMOD(ccolamd)(A, fsetok, fsizeok, NULL, Pok, cm) ; NOT (ok) ;
3192 ok = CHOLMOD(csymamd)(A, NULL, Pok, cm) ; NOT (ok) ;
3193 for (trial = 0 ; trial < 7 ; trial++)
3194 {
3195 test_memory_handler ( ) ;
3196 my_tries = trial ;
3197 ok = CHOLMOD(csymamd)(A, NULL, Pok, cm) ; NOT (ok) ;
3198 }
3199
3200 if (A->nrow == A->ncol && A->packed)
3201 {
3202 test_memory_handler ( ) ;
3203 my_tries = 8 ;
3204 ok = CHOLMOD(csymamd)(A, NULL, Pok, cm) ; OK (ok) ;
3205 test_memory_handler ( ) ;
3206 ok = CHOLMOD(csymamd)(A, NULL, Pok, cm) ; NOT (ok) ;
3207 OK (cm->status == CHOLMOD_OUT_OF_MEMORY) ;
3208 }
3209
3210 for (trial = 0 ; trial < 5 ; trial++)
3211 {
3212 test_memory_handler ( ) ;
3213 my_tries = trial ;
3214 ok = CHOLMOD(camd)(A, NULL, 0, NULL, Pok, cm) ;
3215 if (A->nrow == 0)
3216 {
3217 OK (ok) ;
3218 }
3219 else
3220 {
3221 NOT (ok) ;
3222 }
3223 }
3224 #endif
3225
3226 test_memory_handler ( ) ;
3227
3228 ok = CHOLMOD(etree)(A, Parent, cm) ; NOT (ok) ;
3229 ok = CHOLMOD(factorize)(A, L, cm) ; NOT (ok) ;
3230
3231 pp = CHOLMOD(malloc)(4, 0, cm) ; NOP (pp) ;
3232 pp = CHOLMOD(calloc)(4, 0, cm) ; NOP (pp) ;
3233 pp = CHOLMOD(calloc)(Size_max, 1, cm) ; NOP (pp) ;
3234 pp = NULL ;
3235 size = 0 ;
3236 pp = CHOLMOD(realloc)(4, 0, pp, &size, cm) ; NOP (pp) ;
3237 pp = CHOLMOD(realloc)(Size_max, 1, pp, &size, cm) ; NOP (pp) ;
3238
3239 normal_memory_handler ( ) ;
3240 OK (CHOLMOD(print_sparse)(A, "A ok", cm)) ;
3241 OK (CHOLMOD(print_factor)(L, "L ok", cm)) ;
3242
3243 /* test no_workspace_reallocate flag */
3244 CHOLMOD (free_work) (cm) ;
3245 CHOLMOD (allocate_work) (1, 1, 1, cm) ;
3246 OK (cm->status == CHOLMOD_OK) ;
3247 cm->no_workspace_reallocate = TRUE ;
3248 ok = CHOLMOD (allocate_work) (2, 1, 1, cm) ;
3249 NOT (ok) ;
3250 ok = CHOLMOD (allocate_work) (1, 2, 1, cm) ;
3251 NOT (ok) ;
3252 ok = CHOLMOD (allocate_work) (1, 1, 2, cm) ;
3253 NOT (ok) ;
3254 cm->no_workspace_reallocate = FALSE ;
3255 ok = CHOLMOD (allocate_work) (1, 1, 2, cm) ;
3256 OK (ok) ;
3257
3258 cm->print = 4 ;
3259 ok = CHOLMOD(print_factor)(L, "L for copy", cm) ;
3260 OK (ok) ;
3261 ok = FALSE ;
3262 test_memory_handler ( ) ;
3263 for (trial = 0 ; !ok && trial < 100 ; trial++)
3264 {
3265 my_tries = trial ;
3266 Lcopy = CHOLMOD(copy_factor)(L, cm) ;
3267 ok = (Lcopy != NULL) ;
3268 }
3269 normal_memory_handler ( ) ;
3270 ok = CHOLMOD(print_factor)(Lcopy, "Lcopy", cm) ;
3271 OK (ok) ;
3272 CHOLMOD(free_factor)(&Lcopy, cm) ;
3273 cm->print = 1 ;
3274
3275 test_memory_handler ( ) ;
3276 ok = CHOLMOD(resymbol)(A, NULL, 0, TRUE, L, cm) ; NOT (ok) ;
3277 ok = CHOLMOD(resymbol_noperm)(A, NULL, 0, TRUE, L, cm) ; NOT (ok) ;
3278
3279 lr = CHOLMOD(postorder)(Parent, nrow, NULL, Post, cm) ; NOT (lr>=0) ;
3280
3281 T = CHOLMOD(copy_triplet)(Tok, cm) ; NOT (ok) ;
3282
3283 #ifndef NPARTITION
3284 lr = CHOLMOD(nested_dissection)(A, NULL, 0, Pok, CParent,
3285 Cmember, cm) ;
3286 if (nrow == 0)
3287 {
3288 OK (lr >= 0) ;
3289 }
3290 else
3291 {
3292 NOT (lr >= 0) ;
3293 }
3294
3295 lr = CHOLMOD(nested_dissection)(Abad2, NULL, 0, Pok, CParent,
3296 Cmember, cm) ;
3297 NOT (lr >= 0) ;
3298
3299 ok = CHOLMOD(metis)(A, NULL, 0, TRUE, Pok, cm) ;
3300
3301 if (nrow == 0)
3302 {
3303 OK (ok) ;
3304 }
3305 else
3306 {
3307 NOT (ok) ;
3308 }
3309 lr = CHOLMOD(bisect)(A, NULL, 0, TRUE, Partition, cm) ;
3310
3311 if (nrow == 0)
3312 {
3313 OK (lr == 0) ;
3314 }
3315 else
3316 {
3317 NOT (lr >= 0) ;
3318 }
3319
3320 lr = CHOLMOD(bisect)(Abad2, NULL, 0, TRUE, Partition, cm) ; NOT (lr >= 0) ;
3321
3322 #endif
3323
3324 if (nrow > 3)
3325 {
3326 ok = CHOLMOD(rowdel)(nrow-2, NULL, L5, cm) ; NOT (ok) ;
3327 ok = CHOLMOD(rowadd)(nrow-2, R, L5, cm) ; NOT (ok) ;
3328 ok = CHOLMOD(updown)(+1, A, L, cm) ; NOT (ok) ;
3329 }
3330
3331 C = CHOLMOD(add)(A, A, one, one, TRUE, TRUE, cm) ; NOP (C) ;
3332 C = CHOLMOD(ssmult)(A, A, 0, TRUE, TRUE, cm) ; NOP (C) ;
3333
3334 ok = CHOLMOD(rowcolcounts)(A, NULL, 0, Parent, Post,
3335 NULL, ColCount, First, Level, cm) ; NOT (ok) ;
3336
3337 ok = CHOLMOD(rowfac)(A, NULL, beta, 0, 0, L, cm) ; NOT (ok) ;
3338 ok = CHOLMOD(transpose_unsym)(A, 1, Pok, NULL, 0, R, cm) ; NOT (ok) ;
3339 ok = CHOLMOD(transpose_sym)(A, 1, Pok, R, cm) ; NOT (ok) ;
3340 if (nrow > 1)
3341 {
3342 ok = CHOLMOD(sort)(A, cm) ; NOT (ok) ;
3343 }
3344
3345 ok = CHOLMOD(row_subtree)(A, AT, 0, Parent, R3, cm) ; NOT (ok) ;
3346 ATi = (AT == NULL) ? NULL : AT->i ;
3347 ok = CHOLMOD(row_lsubtree)(A, ATi, 0, 0, L, R3, cm) ; NOT (ok) ;
3348
3349 normal_memory_handler ( ) ;
3350
3351 /* ---------------------------------------------------------------------- */
3352 /* free the valid objects */
3353 /* ---------------------------------------------------------------------- */
3354
3355 cm->status = CHOLMOD_OK ;
3356
3357 CHOLMOD(free_triplet)(NULL, cm) ;
3358
3359 CHOLMOD(free_sparse)(&R3, cm) ; /* ] */
3360 CHOLMOD(free_sparse)(&R, cm) ; /* ] */
3361 CHOLMOD(free_sparse)(&Acopy, cm) ; /* ] */
3362 CHOLMOD(free_factor)(&L5, cm) ; /* ] */
3363 CHOLMOD(free_factor)(&L2, cm) ; /* ] */
3364
3365 Lbad->xtype = Lxtype ;
3366 CHOLMOD(free_factor)(&Lbad, cm) ; /* ] */
3367
3368 CHOLMOD(free_factor)(&L, cm) ; /* ] */
3369
3370 CHOLMOD(free_triplet)(&T, cm) ;
3371
3372 Axbad->xtype = Axbad_type ;
3373 CHOLMOD(free_sparse)(&Axbad, cm) ; /* ] */
3374
3375 cm->error_handler = my_handler ;
3376
3377 Xbad2->xtype = CHOLMOD_REAL ;
3378 CHOLMOD(free_dense)(&Xbad2, cm) ; /* ] */
3379
3380 Abad2->xtype = Abad2xtype ;
3381 CHOLMOD(free_sparse)(&Abad2, cm) ; /* ] */
3382
3383 CHOLMOD(free_sparse)(&Abad, cm) ; /* ] */
3384
3385 CHOLMOD(free_sparse)(&R0, cm) ;
3386 CHOLMOD(free_sparse)(&R1, cm) ; /* ] */
3387
3388 CHOLMOD(free_sparse)(&Aboth, cm) ; /* ] */
3389 CHOLMOD(free_sparse)(&Sok, cm) ;
3390
3391
3392 CHOLMOD(free)(nrow, sizeof (Int), Pinv, cm) ;
3393 CHOLMOD(free)(nrow, sizeof (Int), Parent, cm) ;
3394 CHOLMOD(free)(nrow, sizeof (Int), Post, cm) ;
3395 CHOLMOD(free)(nrow, sizeof (Int), Cmember, cm) ;
3396 CHOLMOD(free)(nrow, sizeof (Int), CParent, cm) ;
3397 CHOLMOD(free)(nrow, sizeof (Int), Partition, cm) ;
3398 CHOLMOD(free)(nrow, sizeof (Int), ColCount, cm) ;
3399 CHOLMOD(free)(nrow, sizeof (Int), First, cm) ;
3400 CHOLMOD(free)(nrow, sizeof (Int), Level, cm) ; /* ] */
3401
3402 CHOLMOD(free_dense)(&Two, cm) ; /* ] */
3403
3404 CHOLMOD(free_sparse)(&R2, cm) ; /* ] */
3405 CHOLMOD(free)(nrow, sizeof (Int), Pok, cm) ; /* ] */
3406
3407 CHOLMOD(free_sparse)(&I1, cm) ; /* ] */
3408
3409 CHOLMOD(free)(nrow, sizeof (Int), Pbad, cm) ; /* ] */
3410
3411 CHOLMOD(free)(ncol, sizeof (Int), fsetbad, cm) ; /* ] */
3412 CHOLMOD(free)(ncol, sizeof (Int), fsetok, cm) ; /* ] */
3413
3414 CHOLMOD(free_dense)(&Bok, cm) ; /* ] */
3415
3416 CHOLMOD(free_dense)(&Xok, cm) ; /* ] */
3417
3418 CHOLMOD(free_sparse)(&AT, cm) ; /* ] */
3419
3420 CHOLMOD(free_sparse)(&A, cm) ; /* ] */
3421
3422 OK (cm->status == CHOLMOD_OK) ;
3423 printf ("\n------------------------null2 tests: All OK\n") ;
3424 }
3425