Mercurial > octave-nkf

comparison liboctave/UMFPACK/UMFPACK/Source/umf_version.h @ 5164:57077d0ddc8e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2005-02-25 19:55:24 by jwe]
author jwe
date Fri, 25 Feb 2005 19:55:28 +0000
parents
children
comparison
equal deleted inserted replaced
5163:9f3299378193 5164:57077d0ddc8e
1 /* ========================================================================== */
2 /* === umf_version.h ======================================================== */
3 /* ========================================================================== */
4
5 /* -------------------------------------------------------------------------- */
6 /* UMFPACK Version 4.4, Copyright (c) 2005 by Timothy A. Davis. CISE Dept, */
7 /* Univ. of Florida. All Rights Reserved. See ../Doc/License for License. */
8 /* web: http://www.cise.ufl.edu/research/sparse/umfpack */
9 /* -------------------------------------------------------------------------- */
10
11 /*
12 Define routine names, depending on version being compiled.
13
14 DINT: double precision, int's as integers
15 DLONG: double precision, long's as integers
16 ZLONG: complex double precision, long's as integers
17 ZINT: complex double precision, int's as integers
18 */
19
20 /* Set DINT as the default, if nothing is defined */
21 #if !defined (DLONG) && !defined (DINT) && !defined (ZLONG) && !defined (ZINT)
22 #define DINT
23 #endif
24
25 /* Determine if this is a real or complex version */
26 #if defined (ZLONG) || defined (ZINT)
27 #define COMPLEX
28 #endif
29
30 /* -------------------------------------------------------------------------- */
31 /* integer type (Int is int or long) now defined in amd_internal.h */
32 /* -------------------------------------------------------------------------- */
33
34 #if defined (DLONG) || defined (ZLONG)
35 #define LONG_INTEGER
36 #endif
37
38 /* -------------------------------------------------------------------------- */
39 /* Numerical relop macros for correctly handling the NaN case */
40 /* -------------------------------------------------------------------------- */
41
42 /*
43 SCALAR_IS_NAN(x):
44 True if x is NaN. False otherwise. The commonly-existing isnan(x)
45 function could be used, but it's not in Kernighan & Ritchie 2nd edition
46 (ANSI C). It may appear in <math.h>, but I'm not certain about
47 portability. The expression x != x is true if and only if x is NaN,
48 according to the IEEE 754 floating-point standard.
49
50 SCALAR_IS_ZERO(x):
51 True if x is zero. False if x is nonzero, NaN, or +/- Inf.
52 This is (x == 0) if the compiler is IEEE 754 compliant.
53
54 SCALAR_IS_NONZERO(x):
55 True if x is nonzero, NaN, or +/- Inf. False if x zero.
56 This is (x != 0) if the compiler is IEEE 754 compliant.
57
58 SCALAR_IS_LTZERO(x):
59 True if x is < zero or -Inf. False if x is >= 0, NaN, or +Inf.
60 This is (x < 0) if the compiler is IEEE 754 compliant.
61 */
62
63 #if defined (MATHWORKS)
64
65 /* The MathWorks has their own macros in util.h that handle NaN's properly. */
66 #define SCALAR_IS_NAN(x) (utIsNaN (x))
67 #define SCALAR_IS_ZERO(x) (utEQZero (x))
68 #define SCALAR_IS_NONZERO(x) (utNEZero (x))
69 #define SCALAR_IS_LTZERO(x) (utLTZero (x))
70
71 #elif defined (UMF_WINDOWS)
72
73 /* Yes, this is exceedingly ugly. Blame Microsoft, which hopelessly */
74 /* violates the IEEE 754 floating-point standard in a bizarre way. */
75 /* If you're using an IEEE 754-compliant compiler, then x != x is true */
76 /* iff x is NaN. For Microsoft, (x < x) is true iff x is NaN. */
77 /* So either way, this macro safely detects a NaN. */
78 #define SCALAR_IS_NAN(x) (((x) != (x)) || (((x) < (x))))
79 #define SCALAR_IS_ZERO(x) (((x) == 0.) && !SCALAR_IS_NAN(x))
80 #define SCALAR_IS_NONZERO(x) (((x) != 0.) || SCALAR_IS_NAN(x))
81 #define SCALAR_IS_LTZERO(x) (((x) < 0.) && !SCALAR_IS_NAN(x))
82
83 #else
84
85 /* These all work properly, according to the IEEE 754 standard ... except on */
86 /* a PC with windows. Works fine in Linux on the same PC... */
87 #define SCALAR_IS_NAN(x) ((x) != (x))
88 #define SCALAR_IS_ZERO(x) ((x) == 0.)
89 #define SCALAR_IS_NONZERO(x) ((x) != 0.)
90 #define SCALAR_IS_LTZERO(x) ((x) < 0.)
91
92 #endif
93
94 /* scalar absolute value macro. If x is NaN, the result is NaN: */
95 #define SCALAR_ABS(x) ((SCALAR_IS_LTZERO (x)) ? -(x) : (x))
96
97 /* true if an integer (stored in double x) would overflow (or if x is NaN) */
98 #define INT_OVERFLOW(x) ((!((x) * (1.0+1e-8) <= (double) Int_MAX)) \
99 || SCALAR_IS_NAN (x))
100
101 /* print a scalar (avoid printing "-0" for negative zero). */
102 #define PRINT_SCALAR(a) \
103 { \
104 if (SCALAR_IS_NONZERO (a)) \
105 { \
106 PRINTF ((" (%g)", (a))) ; \
107 } \
108 else \
109 { \
110 PRINTF ((" (0)")) ; \
111 } \
112 }
113
114 /* -------------------------------------------------------------------------- */
115 /* Real floating-point arithmetic */
116 /* -------------------------------------------------------------------------- */
117
118 #ifndef COMPLEX
119
120 #define Entry double
121
122 #define SPLIT(s) (1)
123 #define REAL_COMPONENT(c) (c)
124 #define IMAG_COMPONENT(c) (0.)
125 #define ASSIGN(c,s1,s2,p,split) { (c) = (s1)[p] ; }
126 #define CLEAR(c) { (c) = 0. ; }
127 #define CLEAR_AND_INCREMENT(p) { *p++ = 0. ; }
128 #define IS_NAN(a) SCALAR_IS_NAN (a)
129 #define IS_ZERO(a) SCALAR_IS_ZERO (a)
130 #define IS_NONZERO(a) SCALAR_IS_NONZERO (a)
131 #define SCALE_DIV(c,s) { (c) /= (s) ; }
132 #define SCALE(c,s) { (c) *= (s) ; }
133 #define ASSEMBLE(c,a) { (c) += (a) ; }
134 #define ASSEMBLE_AND_INCREMENT(c,p) { (c) += *p++ ; }
135 #define DECREMENT(c,a) { (c) -= (a) ; }
136 #define MULT(c,a,b) { (c) = (a) * (b) ; }
137 #define MULT_CONJ(c,a,b) { (c) = (a) * (b) ; }
138 #define MULT_SUB(c,a,b) { (c) -= (a) * (b) ; }
139 #define MULT_SUB_CONJ(c,a,b) { (c) -= (a) * (b) ; }
140 #define DIV(c,a,b) { (c) = (a) / (b) ; }
141 #define RECIPROCAL(c) { (c) = 1.0 / (c) ; }
142 #define DIV_CONJ(c,a,b) { (c) = (a) / (b) ; }
143 #define APPROX_ABS(s,a) { (s) = SCALAR_ABS (a) ; }
144 #define ABS(s,a) { (s) = SCALAR_ABS (a) ; }
145 #define PRINT_ENTRY(a) PRINT_SCALAR (a)
146
147 /* for flop counts */
148 #define MULTSUB_FLOPS 2. /* c -= a*b */
149 #define DIV_FLOPS 1. /* c = a/b */
150 #define ABS_FLOPS 0. /* c = abs (a) */
151 #define ASSEMBLE_FLOPS 1. /* c += a */
152 #define DECREMENT_FLOPS 1. /* c -= a */
153 #define MULT_FLOPS 1. /* c = a*b */
154 #define SCALE_FLOPS 1. /* c = a/s */
155
156 #else
157
158 /* -------------------------------------------------------------------------- */
159 /* Complex floating-point arithmetic */
160 /* -------------------------------------------------------------------------- */
161
162 /*
163 Note: An alternative to this DoubleComplex type would be to use a
164 struct { double r ; double i ; }. The problem with that method
165 (used by the Sun Performance Library, for example) is that ANSI C provides
166 no guarantee about the layout of a struct. It is possible that the sizeof
167 the struct above would be greater than 2 * sizeof (double). This would
168 mean that the complex BLAS could not be used. The method used here avoids
169 that possibility. ANSI C *does* guarantee that an array of structs has
170 the same size as n times the size of one struct.
171
172 The ANSI C99 version of the C language includes a "double _Complex" type.
173 It should be possible in that case to do the following:
174
175 #define Entry double _Complex
176
177 and remove the DoubleComplex struct. The macros, below, could then be
178 replaced with instrinsic operators. Note that the #define Real and
179 #define Imag should also be removed (they only appear in this file).
180
181 For the MULT, MULT_SUB, MULT_SUB_CONJ, and MULT_CONJ macros,
182 the output argument c cannot be the same as any input argument.
183
184 */
185
186 typedef struct
187 {
188 double component [2] ; /* real and imaginary parts */
189
190 } DoubleComplex ;
191
192 #define Entry DoubleComplex
193 #define Real component [0]
194 #define Imag component [1]
195
196 /* for flop counts */
197 #define MULTSUB_FLOPS 8. /* c -= a*b */
198 #define DIV_FLOPS 9. /* c = a/b */
199 #define ABS_FLOPS 6. /* c = abs (a), count sqrt as one flop */
200 #define ASSEMBLE_FLOPS 2. /* c += a */
201 #define DECREMENT_FLOPS 2. /* c -= a */
202 #define MULT_FLOPS 6. /* c = a*b */
203 #define SCALE_FLOPS 2. /* c = a/s or c = a*s */
204
205 /* -------------------------------------------------------------------------- */
206
207 /* real part of c */
208 #define REAL_COMPONENT(c) ((c).Real)
209
210 /* -------------------------------------------------------------------------- */
211
212 /* imag part of c */
213 #define IMAG_COMPONENT(c) ((c).Imag)
214
215 /* -------------------------------------------------------------------------- */
216
217 /* Return TRUE if a complex number is in split form, FALSE if in packed form */
218 #define SPLIT(sz) ((sz) != (double *) NULL)
219
220 /* -------------------------------------------------------------------------- */
221
222 /* c = (s1) + (s2)*i, if s2 is null, then X is in "packed" format (compatible
223 * with Entry and ANSI C99 double _Complex type). */
224 #define ASSIGN(c,s1,s2,p,split) \
225 { \
226 if (split) \
227 { \
228 (c).Real = (s1)[p] ; \
229 (c).Imag = (s2)[p] ; \
230 } \
231 else \
232 { \
233 (c) = ((Entry *)(s1))[p] ; \
234 } \
235 }
236
237 /* -------------------------------------------------------------------------- */
238
239 /* c = 0 */
240 #define CLEAR(c) \
241 { \
242 (c).Real = 0. ; \
243 (c).Imag = 0. ; \
244 }
245
246 /* -------------------------------------------------------------------------- */
247
248 /* *p++ = 0 */
249 #define CLEAR_AND_INCREMENT(p) \
250 { \
251 p->Real = 0. ; \
252 p->Imag = 0. ; \
253 p++ ; \
254 }
255
256 /* -------------------------------------------------------------------------- */
257
258 /* True if a == 0 */
259 #define IS_ZERO(a) \
260 (SCALAR_IS_ZERO ((a).Real) && SCALAR_IS_ZERO ((a).Imag))
261
262 /* -------------------------------------------------------------------------- */
263
264 /* True if a is NaN */
265 #define IS_NAN(a) \
266 (SCALAR_IS_NAN ((a).Real) || SCALAR_IS_NAN ((a).Imag))
267
268 /* -------------------------------------------------------------------------- */
269
270 /* True if a != 0 */
271 #define IS_NONZERO(a) \
272 (SCALAR_IS_NONZERO ((a).Real) || SCALAR_IS_NONZERO ((a).Imag))
273
274 /* -------------------------------------------------------------------------- */
275
276 /* c /= s */
277 #define SCALE_DIV(c,s) \
278 { \
279 (c).Real /= (s) ; \
280 (c).Imag /= (s) ; \
281 }
282
283 /* -------------------------------------------------------------------------- */
284
285 /* c *= s */
286 #define SCALE(c,s) \
287 { \
288 (c).Real *= (s) ; \
289 (c).Imag *= (s) ; \
290 }
291
292 /* -------------------------------------------------------------------------- */
293
294 /* c += a */
295 #define ASSEMBLE(c,a) \
296 { \
297 (c).Real += (a).Real ; \
298 (c).Imag += (a).Imag ; \
299 }
300
301 /* -------------------------------------------------------------------------- */
302
303 /* c += *p++ */
304 #define ASSEMBLE_AND_INCREMENT(c,p) \
305 { \
306 (c).Real += p->Real ; \
307 (c).Imag += p->Imag ; \
308 p++ ; \
309 }
310
311 /* -------------------------------------------------------------------------- */
312
313 /* c -= a */
314 #define DECREMENT(c,a) \
315 { \
316 (c).Real -= (a).Real ; \
317 (c).Imag -= (a).Imag ; \
318 }
319
320 /* -------------------------------------------------------------------------- */
321
322 /* c = a*b, assert because c cannot be the same as a or b */
323 #define MULT(c,a,b) \
324 { \
325 ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
326 (c).Real = (a).Real * (b).Real - (a).Imag * (b).Imag ; \
327 (c).Imag = (a).Imag * (b).Real + (a).Real * (b).Imag ; \
328 }
329
330 /* -------------------------------------------------------------------------- */
331
332 /* c = a*conjugate(b), assert because c cannot be the same as a or b */
333 #define MULT_CONJ(c,a,b) \
334 { \
335 ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
336 (c).Real = (a).Real * (b).Real + (a).Imag * (b).Imag ; \
337 (c).Imag = (a).Imag * (b).Real - (a).Real * (b).Imag ; \
338 }
339
340 /* -------------------------------------------------------------------------- */
341
342 /* c -= a*b, assert because c cannot be the same as a or b */
343 #define MULT_SUB(c,a,b) \
344 { \
345 ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
346 (c).Real -= (a).Real * (b).Real - (a).Imag * (b).Imag ; \
347 (c).Imag -= (a).Imag * (b).Real + (a).Real * (b).Imag ; \
348 }
349
350 /* -------------------------------------------------------------------------- */
351
352 /* c -= a*conjugate(b), assert because c cannot be the same as a or b */
353 #define MULT_SUB_CONJ(c,a,b) \
354 { \
355 ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
356 (c).Real -= (a).Real * (b).Real + (a).Imag * (b).Imag ; \
357 (c).Imag -= (a).Imag * (b).Real - (a).Real * (b).Imag ; \
358 }
359
360 /* -------------------------------------------------------------------------- */
361
362 /* c = a/b, be careful to avoid underflow and overflow */
363 #ifdef MATHWORKS
364 #define DIV(c,a,b) \
365 { \
366 (void) utDivideComplex ((a).Real, (a).Imag, (b).Real, (b).Imag, \
367 &((c).Real), &((c).Imag)) ; \
368 }
369 #else
370 /* This uses ACM Algo 116, by R. L. Smith, 1962. */
371 /* c can be the same variable as a or b. */
372 /* Ignore NaN case for double relop br>=bi. */
373 #define DIV(c,a,b) \
374 { \
375 double r, den, ar, ai, br, bi ; \
376 br = (b).Real ; \
377 bi = (b).Imag ; \
378 ar = (a).Real ; \
379 ai = (a).Imag ; \
380 if (SCALAR_ABS (br) >= SCALAR_ABS (bi)) \
381 { \
382 r = bi / br ; \
383 den = br + r * bi ; \
384 (c).Real = (ar + ai * r) / den ; \
385 (c).Imag = (ai - ar * r) / den ; \
386 } \
387 else \
388 { \
389 r = br / bi ; \
390 den = r * br + bi ; \
391 (c).Real = (ar * r + ai) / den ; \
392 (c).Imag = (ai * r - ar) / den ; \
393 } \
394 }
395 #endif
396
397 /* -------------------------------------------------------------------------- */
398
399 /* c = 1/c, be careful to avoid underflow and overflow */
400 /* Not used if MATHWORKS is defined. */
401 /* This uses ACM Algo 116, by R. L. Smith, 1962. */
402 /* Ignore NaN case for double relop cr>=ci. */
403 #define RECIPROCAL(c) \
404 { \
405 double r, den, cr, ci ; \
406 cr = (c).Real ; \
407 ci = (c).Imag ; \
408 if (SCALAR_ABS (cr) >= SCALAR_ABS (ci)) \
409 { \
410 r = ci / cr ; \
411 den = cr + r * ci ; \
412 (c).Real = 1.0 / den ; \
413 (c).Imag = - r / den ; \
414 } \
415 else \
416 { \
417 r = cr / ci ; \
418 den = r * cr + ci ; \
419 (c).Real = r / den ; \
420 (c).Imag = - 1.0 / den ; \
421 } \
422 }
423
424
425 /* -------------------------------------------------------------------------- */
426
427 /* c = a/conjugate(b), be careful to avoid underflow and overflow */
428 #ifdef MATHWORKS
429 #define DIV_CONJ(c,a,b) \
430 { \
431 (void) utDivideComplex ((a).Real, (a).Imag, (b).Real, (-(b).Imag), \
432 &((c).Real), &((c).Imag)) ; \
433 }
434 #else
435 /* This uses ACM Algo 116, by R. L. Smith, 1962. */
436 /* c can be the same variable as a or b. */
437 /* Ignore NaN case for double relop br>=bi. */
438 #define DIV_CONJ(c,a,b) \
439 { \
440 double r, den, ar, ai, br, bi ; \
441 br = (b).Real ; \
442 bi = (b).Imag ; \
443 ar = (a).Real ; \
444 ai = (a).Imag ; \
445 if (SCALAR_ABS (br) >= SCALAR_ABS (bi)) \
446 { \
447 r = (-bi) / br ; \
448 den = br - r * bi ; \
449 (c).Real = (ar + ai * r) / den ; \
450 (c).Imag = (ai - ar * r) / den ; \
451 } \
452 else \
453 { \
454 r = br / (-bi) ; \
455 den = r * br - bi; \
456 (c).Real = (ar * r + ai) / den ; \
457 (c).Imag = (ai * r - ar) / den ; \
458 } \
459 }
460 #endif
461
462 /* -------------------------------------------------------------------------- */
463
464 /* approximate absolute value, s = |r|+|i| */
465 #define APPROX_ABS(s,a) \
466 { \
467 (s) = SCALAR_ABS ((a).Real) + SCALAR_ABS ((a).Imag) ; \
468 }
469
470 /* -------------------------------------------------------------------------- */
471
472 /* exact absolute value, s = sqrt (a.real^2 + amag^2) */
473 #ifdef MATHWORKS
474 #define ABS(s,a) \
475 { \
476 (s) = utFdlibm_hypot ((a).Real, (a).Imag) ; \
477 }
478 #else
479 /* Ignore NaN case for the double relops ar>=ai and ar+ai==ar. */
480 #define ABS(s,a) \
481 { \
482 double r, ar, ai ; \
483 ar = SCALAR_ABS ((a).Real) ; \
484 ai = SCALAR_ABS ((a).Imag) ; \
485 if (ar >= ai) \
486 { \
487 if (ar + ai == ar) \
488 { \
489 (s) = ar ; \
490 } \
491 else \
492 { \
493 r = ai / ar ; \
494 (s) = ar * sqrt (1.0 + r*r) ; \
495 } \
496 } \
497 else \
498 { \
499 if (ai + ar == ai) \
500 { \
501 (s) = ai ; \
502 } \
503 else \
504 { \
505 r = ar / ai ; \
506 (s) = ai * sqrt (1.0 + r*r) ; \
507 } \
508 } \
509 }
510 #endif
511
512 /* -------------------------------------------------------------------------- */
513
514 /* print an entry (avoid printing "-0" for negative zero). */
515 #define PRINT_ENTRY(a) \
516 { \
517 if (SCALAR_IS_NONZERO ((a).Real)) \
518 { \
519 PRINTF ((" (%g", (a).Real)) ; \
520 } \
521 else \
522 { \
523 PRINTF ((" (0")) ; \
524 } \
525 if (SCALAR_IS_LTZERO ((a).Imag)) \
526 { \
527 PRINTF ((" - %gi)", -(a).Imag)) ; \
528 } \
529 else if (SCALAR_IS_ZERO ((a).Imag)) \
530 { \
531 PRINTF ((" + 0i)")) ; \
532 } \
533 else \
534 { \
535 PRINTF ((" + %gi)", (a).Imag)) ; \
536 } \
537 }
538
539 /* -------------------------------------------------------------------------- */
540
541 #endif /* #ifndef COMPLEX */
542
543 /* -------------------------------------------------------------------------- */
544 /* Double precision, with int's as integers */
545 /* -------------------------------------------------------------------------- */
546
547 #ifdef DINT
548
549 #define UMF_analyze umf_i_analyze
550 #define UMF_apply_order umf_i_apply_order
551 #define UMF_assemble umfdi_assemble
552 #define UMF_assemble_fixq umfdi_assemble_fixq
553 #define UMF_blas3_update umfdi_blas3_update
554 #define UMF_build_tuples umfdi_build_tuples
555 #define UMF_build_tuples_usage umfdi_build_tuples_usage
556 #define UMF_colamd umf_i_colamd
557 #define UMF_colamd_set_defaults umf_i_colamd_set_defaults
558 #define UMF_create_element umfdi_create_element
559 #define UMF_extend_front umfdi_extend_front
560 #define UMF_free umf_i_free
561 #define UMF_fsize umf_i_fsize
562 #define UMF_garbage_collection umfdi_garbage_collection
563 #define UMF_get_memory umfdi_get_memory
564 #define UMF_grow_front umfdi_grow_front
565 #define UMF_init_front umfdi_init_front
566 #define UMF_is_permutation umf_i_is_permutation
567 #define UMF_kernel umfdi_kernel
568 #define UMF_kernel_init umfdi_kernel_init
569 #define UMF_kernel_init_usage umfdi_kernel_init_usage
570 #define UMF_kernel_wrapup umfdi_kernel_wrapup
571 #define UMF_local_search umfdi_local_search
572 #define UMF_lsolve umfdi_lsolve
573 #define UMF_ltsolve umfdi_ltsolve
574 #define UMF_lhsolve umfdi_lhsolve
575 #define UMF_malloc umf_i_malloc
576 #define UMF_mem_alloc_element umfdi_mem_alloc_element
577 #define UMF_mem_alloc_head_block umfdi_mem_alloc_head_block
578 #define UMF_mem_alloc_tail_block umfdi_mem_alloc_tail_block
579 #define UMF_mem_free_tail_block umfdi_mem_free_tail_block
580 #define UMF_mem_init_memoryspace umfdi_mem_init_memoryspace
581 #define UMF_realloc umf_i_realloc
582 #define UMF_report_perm umf_i_report_perm
583 #define UMF_report_vector umfdi_report_vector
584 #define UMF_row_search umfdi_row_search
585 #define UMF_scale umfdi_scale
586 #define UMF_scale_column umfdi_scale_column
587 #define UMF_set_stats umf_i_set_stats
588 #define UMF_singletons umf_i_singletons
589 #define UMF_solve umfdi_solve
590 #define UMF_start_front umfdi_start_front
591 #define UMF_store_lu umfdi_store_lu
592 #define UMF_store_lu_drop umfdi_store_lu_drop
593 #define UMF_symbolic_usage umfdi_symbolic_usage
594 #define UMF_transpose umfdi_transpose
595 #define UMF_tuple_lengths umfdi_tuple_lengths
596 #define UMF_usolve umfdi_usolve
597 #define UMF_utsolve umfdi_utsolve
598 #define UMF_uhsolve umfdi_uhsolve
599 #define UMF_valid_numeric umfdi_valid_numeric
600 #define UMF_valid_symbolic umfdi_valid_symbolic
601 #define UMF_triplet_map_x umfdi_triplet_map_x
602 #define UMF_triplet_map_nox umfdi_triplet_map_nox
603 #define UMF_triplet_nomap_x umfdi_triplet_nomap_x
604 #define UMF_triplet_nomap_nox umfdi_triplet_nomap_nox
605 #define UMF_2by2 umfdi_2by2
606
607 #define UMFPACK_col_to_triplet umfpack_di_col_to_triplet
608 #define UMFPACK_defaults umfpack_di_defaults
609 #define UMFPACK_free_numeric umfpack_di_free_numeric
610 #define UMFPACK_free_symbolic umfpack_di_free_symbolic
611 #define UMFPACK_get_lunz umfpack_di_get_lunz
612 #define UMFPACK_get_numeric umfpack_di_get_numeric
613 #define UMFPACK_get_symbolic umfpack_di_get_symbolic
614 #define UMFPACK_get_determinant umfpack_di_get_determinant
615 #define UMFPACK_numeric umfpack_di_numeric
616 #define UMFPACK_qsymbolic umfpack_di_qsymbolic
617 #define UMFPACK_report_control umfpack_di_report_control
618 #define UMFPACK_report_info umfpack_di_report_info
619 #define UMFPACK_report_matrix umfpack_di_report_matrix
620 #define UMFPACK_report_numeric umfpack_di_report_numeric
621 #define UMFPACK_report_perm umfpack_di_report_perm
622 #define UMFPACK_report_status umfpack_di_report_status
623 #define UMFPACK_report_symbolic umfpack_di_report_symbolic
624 #define UMFPACK_report_triplet umfpack_di_report_triplet
625 #define UMFPACK_report_vector umfpack_di_report_vector
626 #define UMFPACK_save_numeric umfpack_di_save_numeric
627 #define UMFPACK_save_symbolic umfpack_di_save_symbolic
628 #define UMFPACK_load_numeric umfpack_di_load_numeric
629 #define UMFPACK_load_symbolic umfpack_di_load_symbolic
630 #define UMFPACK_scale umfpack_di_scale
631 #define UMFPACK_solve umfpack_di_solve
632 #define UMFPACK_symbolic umfpack_di_symbolic
633 #define UMFPACK_transpose umfpack_di_transpose
634 #define UMFPACK_triplet_to_col umfpack_di_triplet_to_col
635 #define UMFPACK_wsolve umfpack_di_wsolve
636
637 /* for debugging only: */
638 #define UMF_malloc_count umf_i_malloc_count
639 #define UMF_debug umfdi_debug
640 #define UMF_allocfail umfdi_allocfail
641 #define UMF_gprob umfdi_gprob
642 #define UMF_dump_dense umfdi_dump_dense
643 #define UMF_dump_element umfdi_dump_element
644 #define UMF_dump_rowcol umfdi_dump_rowcol
645 #define UMF_dump_matrix umfdi_dump_matrix
646 #define UMF_dump_current_front umfdi_dump_current_front
647 #define UMF_dump_lu umfdi_dump_lu
648 #define UMF_dump_memory umfdi_dump_memory
649 #define UMF_dump_packed_memory umfdi_dump_packed_memory
650 #define UMF_dump_col_matrix umfdi_dump_col_matrix
651 #define UMF_dump_chain umfdi_dump_chain
652 #define UMF_dump_start umfdi_dump_start
653 #define UMF_dump_rowmerge umfdi_dump_rowmerge
654 #define UMF_dump_diagonal_map umfdi_dump_diagonal_map
655
656 #endif
657
658 /* -------------------------------------------------------------------------- */
659 /* Double precision, with long's as integers */
660 /* -------------------------------------------------------------------------- */
661
662 #ifdef DLONG
663
664 #define UMF_analyze umf_l_analyze
665 #define UMF_apply_order umf_l_apply_order
666 #define UMF_assemble umfdl_assemble
667 #define UMF_assemble_fixq umfdl_assemble_fixq
668 #define UMF_blas3_update umfdl_blas3_update
669 #define UMF_build_tuples umfdl_build_tuples
670 #define UMF_build_tuples_usage umfdl_build_tuples_usage
671 #define UMF_colamd umf_l_colamd
672 #define UMF_colamd_set_defaults umf_l_colamd_set_defaults
673 #define UMF_create_element umfdl_create_element
674 #define UMF_extend_front umfdl_extend_front
675 #define UMF_free umf_l_free
676 #define UMF_fsize umf_l_fsize
677 #define UMF_garbage_collection umfdl_garbage_collection
678 #define UMF_get_memory umfdl_get_memory
679 #define UMF_grow_front umfdl_grow_front
680 #define UMF_init_front umfdl_init_front
681 #define UMF_is_permutation umf_l_is_permutation
682 #define UMF_kernel umfdl_kernel
683 #define UMF_kernel_init umfdl_kernel_init
684 #define UMF_kernel_init_usage umfdl_kernel_init_usage
685 #define UMF_kernel_wrapup umfdl_kernel_wrapup
686 #define UMF_local_search umfdl_local_search
687 #define UMF_lsolve umfdl_lsolve
688 #define UMF_ltsolve umfdl_ltsolve
689 #define UMF_lhsolve umfdl_lhsolve
690 #define UMF_malloc umf_l_malloc
691 #define UMF_mem_alloc_element umfdl_mem_alloc_element
692 #define UMF_mem_alloc_head_block umfdl_mem_alloc_head_block
693 #define UMF_mem_alloc_tail_block umfdl_mem_alloc_tail_block
694 #define UMF_mem_free_tail_block umfdl_mem_free_tail_block
695 #define UMF_mem_init_memoryspace umfdl_mem_init_memoryspace
696 #define UMF_realloc umf_l_realloc
697 #define UMF_report_perm umf_l_report_perm
698 #define UMF_report_vector umfdl_report_vector
699 #define UMF_row_search umfdl_row_search
700 #define UMF_scale umfdl_scale
701 #define UMF_scale_column umfdl_scale_column
702 #define UMF_set_stats umf_l_set_stats
703 #define UMF_singletons umf_l_singletons
704 #define UMF_solve umfdl_solve
705 #define UMF_start_front umfdl_start_front
706 #define UMF_store_lu umfdl_store_lu
707 #define UMF_store_lu_drop umfdl_store_lu_drop
708 #define UMF_symbolic_usage umfdl_symbolic_usage
709 #define UMF_transpose umfdl_transpose
710 #define UMF_tuple_lengths umfdl_tuple_lengths
711 #define UMF_usolve umfdl_usolve
712 #define UMF_utsolve umfdl_utsolve
713 #define UMF_uhsolve umfdl_uhsolve
714 #define UMF_valid_numeric umfdl_valid_numeric
715 #define UMF_valid_symbolic umfdl_valid_symbolic
716 #define UMF_triplet_map_x umfdl_triplet_map_x
717 #define UMF_triplet_map_nox umfdl_triplet_map_nox
718 #define UMF_triplet_nomap_x umfdl_triplet_nomap_x
719 #define UMF_triplet_nomap_nox umfdl_triplet_nomap_nox
720 #define UMF_2by2 umfdl_2by2
721
722 #define UMFPACK_col_to_triplet umfpack_dl_col_to_triplet
723 #define UMFPACK_defaults umfpack_dl_defaults
724 #define UMFPACK_free_numeric umfpack_dl_free_numeric
725 #define UMFPACK_free_symbolic umfpack_dl_free_symbolic
726 #define UMFPACK_get_lunz umfpack_dl_get_lunz
727 #define UMFPACK_get_numeric umfpack_dl_get_numeric
728 #define UMFPACK_get_symbolic umfpack_dl_get_symbolic
729 #define UMFPACK_get_determinant umfpack_dl_get_determinant
730 #define UMFPACK_numeric umfpack_dl_numeric
731 #define UMFPACK_qsymbolic umfpack_dl_qsymbolic
732 #define UMFPACK_report_control umfpack_dl_report_control
733 #define UMFPACK_report_info umfpack_dl_report_info
734 #define UMFPACK_report_matrix umfpack_dl_report_matrix
735 #define UMFPACK_report_numeric umfpack_dl_report_numeric
736 #define UMFPACK_report_perm umfpack_dl_report_perm
737 #define UMFPACK_report_status umfpack_dl_report_status
738 #define UMFPACK_report_symbolic umfpack_dl_report_symbolic
739 #define UMFPACK_report_triplet umfpack_dl_report_triplet
740 #define UMFPACK_report_vector umfpack_dl_report_vector
741 #define UMFPACK_save_numeric umfpack_dl_save_numeric
742 #define UMFPACK_save_symbolic umfpack_dl_save_symbolic
743 #define UMFPACK_load_numeric umfpack_dl_load_numeric
744 #define UMFPACK_load_symbolic umfpack_dl_load_symbolic
745 #define UMFPACK_scale umfpack_dl_scale
746 #define UMFPACK_solve umfpack_dl_solve
747 #define UMFPACK_symbolic umfpack_dl_symbolic
748 #define UMFPACK_transpose umfpack_dl_transpose
749 #define UMFPACK_triplet_to_col umfpack_dl_triplet_to_col
750 #define UMFPACK_wsolve umfpack_dl_wsolve
751
752 /* for debugging only: */
753 #define UMF_malloc_count umf_l_malloc_count
754 #define UMF_debug umfdl_debug
755 #define UMF_allocfail umfdl_allocfail
756 #define UMF_gprob umfdl_gprob
757 #define UMF_dump_dense umfdl_dump_dense
758 #define UMF_dump_element umfdl_dump_element
759 #define UMF_dump_rowcol umfdl_dump_rowcol
760 #define UMF_dump_matrix umfdl_dump_matrix
761 #define UMF_dump_current_front umfdl_dump_current_front
762 #define UMF_dump_lu umfdl_dump_lu
763 #define UMF_dump_memory umfdl_dump_memory
764 #define UMF_dump_packed_memory umfdl_dump_packed_memory
765 #define UMF_dump_col_matrix umfdl_dump_col_matrix
766 #define UMF_dump_chain umfdl_dump_chain
767 #define UMF_dump_start umfdl_dump_start
768 #define UMF_dump_rowmerge umfdl_dump_rowmerge
769 #define UMF_dump_diagonal_map umfdl_dump_diagonal_map
770
771 #endif
772
773 /* -------------------------------------------------------------------------- */
774 /* Complex double precision, with int's as integers */
775 /* -------------------------------------------------------------------------- */
776
777 #ifdef ZINT
778
779 #define UMF_analyze umf_i_analyze
780 #define UMF_apply_order umf_i_apply_order
781 #define UMF_assemble umfzi_assemble
782 #define UMF_assemble_fixq umfzi_assemble_fixq
783 #define UMF_blas3_update umfzi_blas3_update
784 #define UMF_build_tuples umfzi_build_tuples
785 #define UMF_build_tuples_usage umfzi_build_tuples_usage
786 #define UMF_colamd umf_i_colamd
787 #define UMF_colamd_set_defaults umf_i_colamd_set_defaults
788 #define UMF_create_element umfzi_create_element
789 #define UMF_extend_front umfzi_extend_front
790 #define UMF_free umf_i_free
791 #define UMF_fsize umf_i_fsize
792 #define UMF_garbage_collection umfzi_garbage_collection
793 #define UMF_get_memory umfzi_get_memory
794 #define UMF_grow_front umfzi_grow_front
795 #define UMF_init_front umfzi_init_front
796 #define UMF_is_permutation umf_i_is_permutation
797 #define UMF_kernel umfzi_kernel
798 #define UMF_kernel_init umfzi_kernel_init
799 #define UMF_kernel_init_usage umfzi_kernel_init_usage
800 #define UMF_kernel_wrapup umfzi_kernel_wrapup
801 #define UMF_local_search umfzi_local_search
802 #define UMF_lsolve umfzi_lsolve
803 #define UMF_ltsolve umfzi_ltsolve
804 #define UMF_lhsolve umfzi_lhsolve
805 #define UMF_malloc umf_i_malloc
806 #define UMF_mem_alloc_element umfzi_mem_alloc_element
807 #define UMF_mem_alloc_head_block umfzi_mem_alloc_head_block
808 #define UMF_mem_alloc_tail_block umfzi_mem_alloc_tail_block
809 #define UMF_mem_free_tail_block umfzi_mem_free_tail_block
810 #define UMF_mem_init_memoryspace umfzi_mem_init_memoryspace
811 #define UMF_realloc umf_i_realloc
812 #define UMF_report_perm umf_i_report_perm
813 #define UMF_report_vector umfzi_report_vector
814 #define UMF_row_search umfzi_row_search
815 #define UMF_scale umfzi_scale
816 #define UMF_scale_column umfzi_scale_column
817 #define UMF_set_stats umfzi_set_stats
818 #define UMF_singletons umf_i_singletons
819 #define UMF_solve umfzi_solve
820 #define UMF_start_front umfzi_start_front
821 #define UMF_store_lu umfzi_store_lu
822 #define UMF_store_lu_drop umfzi_store_lu_drop
823 #define UMF_symbolic_usage umfzi_symbolic_usage
824 #define UMF_transpose umfzi_transpose
825 #define UMF_tuple_lengths umfzi_tuple_lengths
826 #define UMF_usolve umfzi_usolve
827 #define UMF_utsolve umfzi_utsolve
828 #define UMF_uhsolve umfzi_uhsolve
829 #define UMF_valid_numeric umfzi_valid_numeric
830 #define UMF_valid_symbolic umfzi_valid_symbolic
831 #define UMF_triplet_map_x umfzi_triplet_map_x
832 #define UMF_triplet_map_nox umfzi_triplet_map_nox
833 #define UMF_triplet_nomap_x umfzi_triplet_nomap_x
834 #define UMF_triplet_nomap_nox umfzi_triplet_nomap_nox
835 #define UMF_2by2 umfzi_2by2
836
837 #define UMFPACK_col_to_triplet umfpack_zi_col_to_triplet
838 #define UMFPACK_defaults umfpack_zi_defaults
839 #define UMFPACK_free_numeric umfpack_zi_free_numeric
840 #define UMFPACK_free_symbolic umfpack_zi_free_symbolic
841 #define UMFPACK_get_lunz umfpack_zi_get_lunz
842 #define UMFPACK_get_numeric umfpack_zi_get_numeric
843 #define UMFPACK_get_symbolic umfpack_zi_get_symbolic
844 #define UMFPACK_get_determinant umfpack_zi_get_determinant
845 #define UMFPACK_numeric umfpack_zi_numeric
846 #define UMFPACK_qsymbolic umfpack_zi_qsymbolic
847 #define UMFPACK_report_control umfpack_zi_report_control
848 #define UMFPACK_report_info umfpack_zi_report_info
849 #define UMFPACK_report_matrix umfpack_zi_report_matrix
850 #define UMFPACK_report_numeric umfpack_zi_report_numeric
851 #define UMFPACK_report_perm umfpack_zi_report_perm
852 #define UMFPACK_report_status umfpack_zi_report_status
853 #define UMFPACK_report_symbolic umfpack_zi_report_symbolic
854 #define UMFPACK_report_triplet umfpack_zi_report_triplet
855 #define UMFPACK_report_vector umfpack_zi_report_vector
856 #define UMFPACK_save_numeric umfpack_zi_save_numeric
857 #define UMFPACK_save_symbolic umfpack_zi_save_symbolic
858 #define UMFPACK_load_numeric umfpack_zi_load_numeric
859 #define UMFPACK_load_symbolic umfpack_zi_load_symbolic
860 #define UMFPACK_scale umfpack_zi_scale
861 #define UMFPACK_solve umfpack_zi_solve
862 #define UMFPACK_symbolic umfpack_zi_symbolic
863 #define UMFPACK_transpose umfpack_zi_transpose
864 #define UMFPACK_triplet_to_col umfpack_zi_triplet_to_col
865 #define UMFPACK_wsolve umfpack_zi_wsolve
866
867 /* for debugging only: */
868 #define UMF_malloc_count umf_i_malloc_count
869 #define UMF_debug umfzi_debug
870 #define UMF_allocfail umfzi_allocfail
871 #define UMF_gprob umfzi_gprob
872 #define UMF_dump_dense umfzi_dump_dense
873 #define UMF_dump_element umfzi_dump_element
874 #define UMF_dump_rowcol umfzi_dump_rowcol
875 #define UMF_dump_matrix umfzi_dump_matrix
876 #define UMF_dump_current_front umfzi_dump_current_front
877 #define UMF_dump_lu umfzi_dump_lu
878 #define UMF_dump_memory umfzi_dump_memory
879 #define UMF_dump_packed_memory umfzi_dump_packed_memory
880 #define UMF_dump_col_matrix umfzi_dump_col_matrix
881 #define UMF_dump_chain umfzi_dump_chain
882 #define UMF_dump_start umfzi_dump_start
883 #define UMF_dump_rowmerge umfzi_dump_rowmerge
884 #define UMF_dump_diagonal_map umfzi_dump_diagonal_map
885
886 #endif
887
888 /* -------------------------------------------------------------------------- */
889 /* Complex double precision, with long's as integers */
890 /* -------------------------------------------------------------------------- */
891
892 #ifdef ZLONG
893
894 #define UMF_analyze umf_l_analyze
895 #define UMF_apply_order umf_l_apply_order
896 #define UMF_assemble umfzl_assemble
897 #define UMF_assemble_fixq umfzl_assemble_fixq
898 #define UMF_blas3_update umfzl_blas3_update
899 #define UMF_build_tuples umfzl_build_tuples
900 #define UMF_build_tuples_usage umfzl_build_tuples_usage
901 #define UMF_colamd umf_l_colamd
902 #define UMF_colamd_set_defaults umf_l_colamd_set_defaults
903 #define UMF_create_element umfzl_create_element
904 #define UMF_extend_front umfzl_extend_front
905 #define UMF_free umf_l_free
906 #define UMF_fsize umf_l_fsize
907 #define UMF_garbage_collection umfzl_garbage_collection
908 #define UMF_get_memory umfzl_get_memory
909 #define UMF_grow_front umfzl_grow_front
910 #define UMF_init_front umfzl_init_front
911 #define UMF_is_permutation umf_l_is_permutation
912 #define UMF_kernel umfzl_kernel
913 #define UMF_kernel_init umfzl_kernel_init
914 #define UMF_kernel_init_usage umfzl_kernel_init_usage
915 #define UMF_kernel_wrapup umfzl_kernel_wrapup
916 #define UMF_local_search umfzl_local_search
917 #define UMF_lsolve umfzl_lsolve
918 #define UMF_ltsolve umfzl_ltsolve
919 #define UMF_lhsolve umfzl_lhsolve
920 #define UMF_malloc umf_l_malloc
921 #define UMF_mem_alloc_element umfzl_mem_alloc_element
922 #define UMF_mem_alloc_head_block umfzl_mem_alloc_head_block
923 #define UMF_mem_alloc_tail_block umfzl_mem_alloc_tail_block
924 #define UMF_mem_free_tail_block umfzl_mem_free_tail_block
925 #define UMF_mem_init_memoryspace umfzl_mem_init_memoryspace
926 #define UMF_realloc umf_l_realloc
927 #define UMF_report_perm umf_l_report_perm
928 #define UMF_report_vector umfzl_report_vector
929 #define UMF_row_search umfzl_row_search
930 #define UMF_scale umfzl_scale
931 #define UMF_scale_column umfzl_scale_column
932 #define UMF_set_stats umfzl_set_stats
933 #define UMF_singletons umf_l_singletons
934 #define UMF_solve umfzl_solve
935 #define UMF_start_front umfzl_start_front
936 #define UMF_store_lu umfzl_store_lu
937 #define UMF_store_lu_drop umfzl_store_lu_drop
938 #define UMF_symbolic_usage umfzl_symbolic_usage
939 #define UMF_transpose umfzl_transpose
940 #define UMF_tuple_lengths umfzl_tuple_lengths
941 #define UMF_usolve umfzl_usolve
942 #define UMF_utsolve umfzl_utsolve
943 #define UMF_uhsolve umfzl_uhsolve
944 #define UMF_valid_numeric umfzl_valid_numeric
945 #define UMF_valid_symbolic umfzl_valid_symbolic
946 #define UMF_triplet_map_x umfzl_triplet_map_x
947 #define UMF_triplet_map_nox umfzl_triplet_map_nox
948 #define UMF_triplet_nomap_x umfzl_triplet_nomap_x
949 #define UMF_triplet_nomap_nox umfzl_triplet_nomap_nox
950 #define UMF_2by2 umfzl_2by2
951
952 #define UMFPACK_col_to_triplet umfpack_zl_col_to_triplet
953 #define UMFPACK_defaults umfpack_zl_defaults
954 #define UMFPACK_free_numeric umfpack_zl_free_numeric
955 #define UMFPACK_free_symbolic umfpack_zl_free_symbolic
956 #define UMFPACK_get_lunz umfpack_zl_get_lunz
957 #define UMFPACK_get_numeric umfpack_zl_get_numeric
958 #define UMFPACK_get_symbolic umfpack_zl_get_symbolic
959 #define UMFPACK_get_determinant umfpack_zl_get_determinant
960 #define UMFPACK_numeric umfpack_zl_numeric
961 #define UMFPACK_qsymbolic umfpack_zl_qsymbolic
962 #define UMFPACK_report_control umfpack_zl_report_control
963 #define UMFPACK_report_info umfpack_zl_report_info
964 #define UMFPACK_report_matrix umfpack_zl_report_matrix
965 #define UMFPACK_report_numeric umfpack_zl_report_numeric
966 #define UMFPACK_report_perm umfpack_zl_report_perm
967 #define UMFPACK_report_status umfpack_zl_report_status
968 #define UMFPACK_report_symbolic umfpack_zl_report_symbolic
969 #define UMFPACK_report_triplet umfpack_zl_report_triplet
970 #define UMFPACK_report_vector umfpack_zl_report_vector
971 #define UMFPACK_save_numeric umfpack_zl_save_numeric
972 #define UMFPACK_save_symbolic umfpack_zl_save_symbolic
973 #define UMFPACK_load_numeric umfpack_zl_load_numeric
974 #define UMFPACK_load_symbolic umfpack_zl_load_symbolic
975 #define UMFPACK_scale umfpack_zl_scale
976 #define UMFPACK_solve umfpack_zl_solve
977 #define UMFPACK_symbolic umfpack_zl_symbolic
978 #define UMFPACK_transpose umfpack_zl_transpose
979 #define UMFPACK_triplet_to_col umfpack_zl_triplet_to_col
980 #define UMFPACK_wsolve umfpack_zl_wsolve
981
982 /* for debugging only: */
983 #define UMF_malloc_count umf_l_malloc_count
984 #define UMF_debug umfzl_debug
985 #define UMF_allocfail umfzl_allocfail
986 #define UMF_gprob umfzl_gprob
987 #define UMF_dump_dense umfzl_dump_dense
988 #define UMF_dump_element umfzl_dump_element
989 #define UMF_dump_rowcol umfzl_dump_rowcol
990 #define UMF_dump_matrix umfzl_dump_matrix
991 #define UMF_dump_current_front umfzl_dump_current_front
992 #define UMF_dump_lu umfzl_dump_lu
993 #define UMF_dump_memory umfzl_dump_memory
994 #define UMF_dump_packed_memory umfzl_dump_packed_memory
995 #define UMF_dump_col_matrix umfzl_dump_col_matrix
996 #define UMF_dump_chain umfzl_dump_chain
997 #define UMF_dump_start umfzl_dump_start
998 #define UMF_dump_rowmerge umfzl_dump_rowmerge
999 #define UMF_dump_diagonal_map umfzl_dump_diagonal_map
1000
1001 #endif