p¶

·

’ gc ”8

˜© ˜ ªpv

88 8k10 ³

¨

§

¨¥ c© ¨ ¥£" Bc

$ ¡©

¢

¡

For (1), the usual technique is to generate a full row and accumulate the linear combination

of the previous rows in it. The row is zeroed again after the whole loop is ¬nished using

a sparse set-to-zero operation. A variation on this technique uses only a full integer array

®

C

, the values of which are zero except when there is a nonzero element. With this

`¥

a

G ` a

v£ ±

full row, a short real vector must be maintained which contains the real

G ` ¥ a

7£ ±

values of the row, as well as a corresponding short integer array which

G

points to the column position of the real values in the row. When a nonzero element resides C ¥%

in position of the row, then is set to the address in where the nonzero

a ¥` ¥

¥ C C

¡ ` ¥ a¡` ¥ aY`

element is stored. Thus, points to , and points to and . This a a ¥` ¥ a ¥` ¥

is illustrated in Figure 10.11.

C

: nonzero

¥

0 0 0 0 3 0 0 0 0 0

1 2 4 indicator

¥ : pointer to nonzero elements

7 9

2 4

: real values

D5"0# ¥ ¥£ ¥

§ § ¢ § ¤¡

Illustration of data structure used for the work-

ing row in ILUT.

C

Note that holds the information on the row consisting of both the part and the

¥

¦

part of the LU factorization. When the linear combinations of the rows are performed,

¬rst determine the pivot. Then, unless it is small enough to be dropped according to the

dropping rule being used, proceed with the elimination. If a new element in the linear C E

¡ ` C

©‚a

¢

combination is not a ¬ll-in, i.e., if , then update the real value . If it is a `¥ a

¥

”a ¥ ` C E ¥%

¬ll-in (¥ ), then append an element to the arrays and update accordingly. ¥

U U

For (2), the natural technique is to employ a heap-sort strategy. The cost of this imple-

@ @ @

± « ” w o±` ±«

¯ ±o`

¡ ¡

mentation would be , i.e., for the heap construction and a a ` a

for each extraction. Another implementation is to use a modi¬ed quick-sort strategy based

on the fact that sorting the array is not necessary. Only the largest elements must be ex-

tracted. This is a quick-split technique to distinguish it from the full quick-sort. The method

a`

¡

±

consists of choosing an element, e.g., , in the array , then permuting

G ` a

¡ ¡ ` ¡ G

3 ¡ Y` ¡ ± ± ±

the data so that if and if , where is

a

¡ ¡ ¡ ¡

3 a 4h

¢ ¢)h )

¢

±

some split point. If , then exit. Otherwise, split one of the left or right sub-arrays

)h

¢

±

recursively, depending on whether is smaller or larger than . The cost of this strategy

¢)

@

x±`

on the average is . The savings relative to the simpler bubble sort or insertion sort

a

schemes are small for small values of , but they become rather signi¬cant for large and

± .

The next implementation dif¬culty is that the elements in the part of the row being

built are not in an increasing order of columns. Since these elements must be accessed from

left to right in the elimination process, all elements in the row after those already elimi-

pp¶

¶· 8˜ H ˜ ¤ ¨°¡ $ H&’ ”8 ” &’ ¤ ©¦§

©8 $ $

¡¨ ¨¦ ¤

© §¥ c#&) $

©1

¢

¡

nated must be scanned. The one with smallest column number is then picked as the next

element to eliminate. This operation can be ef¬ciently organized as a binary search tree

which allows easy insertions and searches. However, this improvement is rather complex

to implement and is likely to yield moderate gains.

¥

"0# ¥§¨

¢§ ©

Tables 10.3 and 10.4 show the results of applying GMRES(10) precon-

E E

ditioned with ILUT(1% ) and ILUT(5% ), respectively, to the ¬ve test problems

d d

G G