AD-A272 648

VV.R'
ET~7

Fast Fourier Transforms of I ,.

Piecewise Constant Functions -
By

Eugene Sorets
Research Report YALEU/DCS/RR-986 AV,]
September 1993 i

-", 93 -27509

YALE UNIVERSITY
DEPARTMENT OF COMPUTER SCIENCE

0 0 0 0 0 0
 We present an algorithm for the evaluation of the Fourier transform of piecewise constant
functions of two variables. The algorithm overcomes the accuracy problems associated with
computing the Fourier transform of discontinuous functions; in fact, its time complexity
is O(log3 (l/)N 2 + log 2 (1/E)N 2 ]logN), where t is the accuracy and N is the size of the
problem. The algorithm is based on the Lagrange interpolation formula and the Green's
theorem, which are used to preprocess the data before applying the Fast Fourier transform.
It admits natural generalizations to higher dimensions and to piecewise smooth functions.

-, N

Acce~ierl Fo! I
L;TJS (•A •

Fast Fourier Transforms of,.

Piecewise Constant Functions

--
-
Eugene Sorets ...
Research Report YALEU/DCS/RR-986 PW"!ifIty Cc5
September 1993 v!
V Z'o
4 Dist
SIcial

M/L

The author was supported by the National Science Foundation under Grant DMS901213595.
Approved for public release: distribution is unlimited.
Keywords: Fourier Transform, Fast Algorithms.

4 I III I I ISI~ i~
Contents
1 Introduction 1

2 Mathematical Preliminaries 1
2.1 Lagrange Interpolation .............................. 1
2.2 Green's theorem ......... ................................. 3
2.3 Gauss-Legendre Quadratures ....... .......................... 3

3 Mathematical Description of the Algorithm 3

3.1 Statement of the Problem ......... ............................ 3
3.2 Description of the Algorithm ....... .......................... 4
3.3 Error Estimates ......... .................................. 6

4 Formal Description of the Algorithm 10 0

4.1 Description of the Algorithm ........ .......................... 10
4.2 Complexity Analysis of the Algorithm ....... ..................... 12

5 Numerical Experiments 13

6 Conclusions and Generalizations 17

6.1 Generalizations .......... .................................. 17
6.2 Conclusions .......... .................................... 17

References 17

• • • •• • •S

!1[ []nn un
nlmm-n-,
nn u-,,,--nn
,, nu nu

uu
[ • m n~nm•
[]n mm •i~m n
 1 Introduction
The Fast Fourier Transform (see, for example, [2, 3, 8)) is a ubiquitous tool of numerical
analysis, essential in signal processing, electrical engineering, VLSI circuit modeling, medical
imaging, and innumerable other fields. It is a very effective tool when the function to be
transformed is smooth: however, if the function has a jump discontinuity, then the accuracy
of the FFT is significantly reduced. This loss of accuracy is the result of the simple fact
that FFT, from the mathematical point of view, is a collection of integrals evaluated with
trapezoidal rule. Therefore, the numerical error that results from the discontinuity is on the
order of n- 1 for a problem of size n. Such errors make even single precision calculations,
especially in higher dimensions, prohibitively costly. The cost can be reduced with the
help of the Richardson extrapolation, but double precision calculations are still virtually
impossible.
We construct an algorithm that successfully attacks this problem; for example, on a
512 x 512 array our implementation takes about 50 times the CPU time of one 512 x 512
FFT for single precision results and about 160 times for double precision.
The algorithm uses Green's theorem to replace the area integrals, that naturally occur in
computing the two-dimensional Fourier transform of piecewise constant functions, with line
integrals, thereby reducing significantly the number of nodes required for integration: after
that the weights are redistributed onto the uniform grid with the help of the Lagrange inter-
polation formula, bringing the data to the form suita'Ae for the FFT, A detailed description
of the algorithm can be found in Section 4. and performance results in Section 5.
In this paper. we present the analysis in two dimensions under the assumption that the
functions to be transformed are piecewise constant and that the discontinuities occur along
a collection of polygons. Neither of these is a serious limitation; the algorithm generalizes
quite naturally to higher dimensions and to curved boundaries. In Section 6 we describe a
generalization of our algorithm to piecewise smooth functions.
Acknowledgements: The author would like to thank Professors Ronald Coifinan and
Vladimir Rokhlin for several useful discussions. He would also like to thank Professor Eytan
Barouch for suggesting the problem and supplying the VLSI masks for the experiments.

2 Mathematical Preliminaries
2.1 Lagrange Interpolation
The Lagrange interpolation formula (see, for example, [1, 4)) approximates a function f
11 - C1 by the expression:
p p

f nl fW l -X XZ-n.

rn=1 X~tn - X
niom

* 0 * S * S S * 0 0
where x, < ... < x, are points on the real line and Rv(x) is the error term. For each
m = 1-. p, we will denote by 6m the polynomial defined by the formula:
p
b•(x) = 11 -x
.1 Zm Z7 (

and observe that r 1 if n= n,

0 if nz n.

In view of (2), formula (1) can be rewritten as

p
f(X) = E f(xm)bn(x)+ Rp(X). (3)
Mn=1

Rp(x) in equations (1) and (3) is the error term and

)- -- (X -Xn) forsome E(xi. xp).

In our case, the nodes xi . . . . .x . are going to be uniformly spaced with the sampling
interval h > 0, and the point x will he in the interval of length h centered on the center of
the interpolation window [xl,xp]. Furthermore, the function f will be of the form f(xi)
exp(2irikx). Under these conditions,

.2 •[r ( + -1)] h P(27rk)P for odd p.

ir p!

[r(E P.+ 1} • hP(2irk)P for even p

K [r(• + 1)]2 .h•(2,r.)•, (.)

- p!

where F(z) is the Gamma function: F(z + 1) = z!.

We will also make use of the two-dimensional Lagrange interpolation formula: p
P P
f(x, y) = E F, 6,,,(X). -n(Y)"- f(x,, yn + Rp(x, y). 5
n=1 m=1

Here the points {(mi, yn)}1 n=, are the interpolation nodes, the functions 6, .... are the
same as in (2). and the error term, R,(x, y), admits the bound

iR,(x, )I0 21 [hP(2rk)' + hP(27rl)] (6)

p.
when the function f(x, y) has the form exp(2fri(kx+Iy)) and the nodes are uniformly spaced
with the sampling interval h, along the x-axis and h, along the y-axis.

2
 2.2 Green's theorem
We will encounter area integrals of the form

D C -27rtmx C -'2rny
dydx.

where D is a bounded domain in R 2 . We will replace them with line integrals using the
following version of Green's theorem in the plane:

ID 0dyd = Q dy. (7)

Here Q : IR2 - C1 is a function in C 2 (/b) and F is the boundary of D traversed counter-

clockwise. Applying (7) to Q(x,y) =e- 2imx€-2rng, we arrive at a formula that will be
important to us later:

I /-27riCm f - 2"tn dy when m # 0.

JD C-27rtmx C-21rny dydx = -rim 1 (8)
j
I X -27r'ny dy when m 0.

2.3 Gauss-Legendre Quadratures

Gauss-Legendre integration scheme (see. for example, [4, 7]) provides an approximation to
the integral of a function f : [0, 1] - C':
q
(9)
fo f(t)dt E
= k=l f(tk),-' + Eq(f),

where the points tl....tq are the Gauss-Legendre nodes, the numbers wi.. q are the
Gauss-Legendre weights, and Eq(f) is the error term. The Gauss-Legendre nodes and
weights are chosen to make the approximation (9) exact whenever the function f is a
polynomial of degree less than 2q. Consequently. the Gauss-Legendre scheme is effective
for functions that are well approximated by polynomials: in fact:
2q+ I(q! )4 f2,ý

Eq(f) = 2 (q) ftq(•) for some ý E [0, 1]. (10)

(2q + 1)[(2q)!] 3

The proof of (10) can be found in [4].

3 Mathematical Description of the Algorithm

3.1 Statement of the Problem
Our goal in this paper is to find a way to compute Fourier Transforms of piecewise constant
functions in IR2. In other words, we would like to construct an algorithm that for every

0 S 0 0 0 0 0 0 0 0
 O
piecewise constant function f : R2 - C' will compute an approximation to the collection X)

of integrals, to which we will refer as the Fourier Transform 1 of f: •

f(m, n fo1 2
j) je f (x, y)e- 2"wim e- 1riny dydx, (11)

where m and n are integers such that -M < m < M and -N < n < N. We will refer to
the pair (m, n) as the frequency. The pair (M, N), thus, is the highest frequency of interest. •
The most common approximation to the integrals (11), the Discrete Fourier Transform [2] is,
essentially, the trapezoidal rule; its standard implementation is the Fast Fourier Transform
(see, for example, [2, 3, 8]). For discontinuous functions the trapezoidal rule has accuracy
on the order of N-1 for an N by N problem, or, conversely, for accuracy (, will require
on the order of (- 2 operations; such performance is woefully inadequate in most practical
problems.
In this paper we solve the following problem:
Problem 1 For every piecewise constant function f with discontinuities along a finite num-
ber of polygons. and for every accuracy ( > 0, compute all the integrals (11) with accuracy
f in the number of operation not greater than S

0( (log3!) + (log2) A2 log N)v (12)

whfry N = max{M, N}.

Mathematical description and error analysis of the algorithm that solves Problem 1 can be
found in §3.2 and §3.3, respectively. Section 4 contains the full description of the algorithm.
and Section 5 contains the results of some of our numerical experiments. In Section 6 we
describe an extension of the algorithm to piecewise smooth functions.

3.2 Description of the Algorithm 5

A piecewise-constant function f : R2 -- C can be written as a linear combination of
characteristic functions. By the characteristic function 1s : 112 - C1 of a set S C R12 we
mean, as usual:
' ds(Xf 1 if(x.y) E S,
00 otherwise.
Using this notation, we write the piecewise-constant f as:

J
f(xy) =Z KA. ID,(Xzy), (1))

where J is a positive integer constant determined by the problem, and, for each j, h'Kis
a complex constant and D, is a bounded domain in 1R2. We will assume from now on
that all domains Dj lie within the unit square, their interiors are pairwise disjoint, and the
boundaries r, of the domains D, are polygons. Indeed, for each j, let {y/ : [0. 1] - F) _
be the set of paths that form Fr. Then, our assumptions are:

4
 1. i), C [0, 1Jx [0.1 ] for all j, 0
X
2. Int(D,) n Int(Dk) = 0 for all j ý k.

3. Every path -y, has the form: 4"

,yj'(t) =(ao +at, bo +bt) for t E [0, 1]. (14)

The first two assumptions do not restrict generality at all, and the third one is made to
simplify the error estimates and the implementation. It does not affect the algorithm itself.
Substituting (13) into (11) and using (8), we get:

f(m, n) = J K, . 1D,(X, )f7mifn~ i dydx

dydx
- IDD K .'-27rimxe-2rin'

, -'Fn,,,,(x, y) dy, (15)

where each F, is the boundary of the domain D. and the function Fro, : C-1 is
defined by the formula:

Finn =
{lef C_2?rtrnzr C_21riny wh
when
n
m
m 0
0
(16)
IX- 21riny when m = 0.

For each j. let {-y'} be the set of paths that form F,. Along each 7[ we approximate the
line integrals in (15) with the help of Gauss-Legendre quadrature scheme of 2.3. Indeed,
using approximation (9) on each I j and substituting the result into (15) we get:
J L) qt
.f(m, n)•; E K, . Fmn(x< , V,'+ .b.- w (17)
j=1 1=1 k=1

where, for each I, the points {(ft. vv,, ))' =,Lare the images under -y of the Gauss-Legendre
nodes tk of equation (9):
(X, = '(t), (18)
the numbers w I.....
are the corresponding Gauss-Legendre weights, and b has been
defined in equation (14).
In order to be able to use the Fast Fourier Transform, we redistribute the weights
from the Gauss-Legendre nodes in (18) to the uniform grid with the help of the Lagrange
Interpolation formula (5) applied to the function F, at (x,y) = ()(1 , /V,') for each k and I.
The final approximation to f(m, n) becomes:
j L) qD p p
n (19)
j=1 1=1 k=1 J1=12=12=

50
where, for each k and 1, the points {(x k,, k )jP

weeYJ2 fn,2 . 1 are chosen on the uniform grid so that X)

the point (X5, t'•) lies in the h, by hy rectangle centered on the center of the interpolation
window [xk. ] X [Y,, Yk].

Remark 3.1 Changing the order of summation in (19), we see that

(JL)q,
*F ( 1lY 2 , (20)
-&E1 =1 1=1 k=1 2('')y,, (0

where the points {(x,,, y,2 )} form a uniform grid on [0, 1] x [0, 1] with sampling intervals h,
and h.,.
Let G : 72 - (,1 be defined by the term in the parentheses in (20):

j L, q,
G(j 1 ,j 2)'f K, . b j.(X- (21)
j=1 1=1 k=1

Then, substituting (21) into (20). and, using the definition of Fmn in (16), we get:

f(m,n) JyJ
EEG(j,,j2).F,,.n(x
Zt 2)
11 12
( 1
12r 1i E G(jY(,j2 ) . ,-2_im1 1 ,, -27,•,n , 2 when 77 0.
Il 12•

= (22)

G (-i- M X) C_ 2rtny12 when in = 0

which can be readily computed for all in and n with the help of two- and one-dimensional
FFTs. E

3.3 Error Estimates

In this section we estimate the accuracy of the approximations (17) and (19) made in §3.2.
Let 11' be a straight path as defined in (14):

"_Y(t) = (ao + at, be + bt) for t E [0, 11.

Since Gauss-Legendre quadrature and Lagrange interpolation formula are translation in-
variant, the estimates will not change if we assume that a0 = b0 = 0. Then, for every (n. n)
such that - M < m < M and -N < n < N, using (9) and (14), we get:

JFmn(x,y)dy =
01 Fmn,,(atbt).bdt
0
qj

+ b Eq,(Fmn o ). (23)

6
Lemma 3.1 For all (i, n) such that - M < in < M and -N < n < N, thE Error tUrm
EqI in (23) satisfies thE incquality:

1) 23 qL+1(91! ) 4 7r 2 ql /q ___

Eqi(Fm.n 0 1)(2q1)!] 3 M2 + V
2
a2 + b2) . (24)
(2qj+ 1[(2q)Fp27r

Proof. For 't) :[0, 1] - R 2 as defined by (14) with ao = b0 0

S-2iri(rma+nb)t
(F,, 0 )(t) -2 when m 0, (25)
a•t-c• 2
"rinbt when m 0

and, consequently.

d2q' (F,,.,, o [-2 7ri(m a + nb)]2 ql. - 21r( ma+nb)t

2
d qt F ) -2rin (26)
when in : 0, and
d 2qj
d ((2Fnt),
, o
0(-21rinb )2q + 2qi . a . (-27rinb )2q,-] C- 2rmht (27)

when rn = 0.
Let M denote (Mf2 + *V2 )1/ 2 and let L denote (a 2 + b 2 )1/ 2 . Then, it follows from (26)
and (27) that for in $ 0, I
d2qj t) (2r']na + nb])2qj

d2q' rm
- 2 2irIm-I
2
< ( 27r vm -+n _Va2-2q
27r Iin!I
(21r If: L)2q,
< 2rim1 (28)

and. for rn = 0.
d2qj t), 2q -
t( Fmn 0 "tI)O ( -27)inb + 2q," a. (-2,rinb)2 q'-l

S127rnb] 2 -• - 27rinb + 2ql • al

5 j21rnbjqj-I . /(2irn) 2 + (2qj)2 -.v/2 +V

< (2,?.lL)2 qi-I . Vi(27rM)I + (2q,) L

2 - 1+ -
S (27rf L)

((21r R L,)2 q, qj. (29)

7S
 0

I
Putting ( 10), (28). and (29) together, we get an estimate of the error of Gauss-Lcgendre X)
quadrature in (23): 0
4 2
2q,+LI(ql!) (27r f L) q when i 0.
3
Eq,(Fmn.•o /) <_ (2qj + 1)[(2q,)!] 2iror wI
Eqj(Fm~n
0 11 1 <2q,'+ (ql! )4 -( 1l 2,-q h n n
(2qj + 1)[(2q9)!]3 (2r/L)2 q' qt when ,n $ 0
2'11+l1(qj! )4 2, q
< (2ir. ML)2 -
(2qj + 1)[(2q2)!] (2i
which is exactly the claim of the lemma. 0
Corollary 3.1 Let I : [0, 1] - 2 b&a straight path defined by (14), and let Fm,,, b&a 0
function definfd by (16).
ThPn. for ue'ry ( > 0.

JF
,dy1 -
k=1
Fm,,n,(I (tk)) - b 1k I< (30)

whfnwr -. 11 < in < AM.-N < n < N. and

q > const. • max {ML, logi}. (31)

Hurt tk and~--k are the Gauss-Lcgcndrf nodes and weights, respectively, and 1l. L have b (i
dtfind ti (28}).

Proof. Using Stirfing's approximation to q!. we see that for large q the right-hand side of
expression (24 ) is asymptotic to:
2 3q+l (q! )47r2q q 2q I - (( ',• 'L ,) 2 < (4 1L ) 2
-M

(2q + l)[(2q1!J3 2ir 4 V -7r 2 < (32)

Therefore, the inequality (30) will hold if

q > const. . max {M L, log } . (33)

Remark 3.2 The quantity Al is the frequency of the function FMfN along -i, and L is the
length of -. Corollary 3.1. then, imphes that the number of Gauss-Legendre nodes needed
to compute the integral f, FM.N dy with accuracy ( is proportional to the number of periods
of f• along I (so long as that number is greater than log(I/e)). a
After computing Gauss-Legendre nodes and weights. in the equation (19) we redistribute 3
the weights onto the uniform grid with the help of Lagrange interpolation formula:
P P
•,.•,•.,•, P •,(• .• •,) ,, •.ý.y,, )+ Rp(N k-.t'). (34)
31=1 J2=1

The error RP( k. V'1) of this approximation is estimated in the next lemma.

* 6
Lemma 3.2 FOr all (I *,it) such that --. 11 to <..\1 arid - .\ < I the r,-,,it I-,
Hi f . .atz.jit.• tht ztuquality:
LS
Rp! < + 1(2
[) h(.L
.,)" + (27h•,. I',

p.
p -21
<_ / -ir (2 1rh , Af ) "+ ( 2 7r h \N, 3 , I'

for p > 2.

Proof. For in 0. (35) follows directly from (61. \Vhei III = 0. v-:, oberv, that IIi.
function x is approxiniatld exactly by L.agrange interpolation formula for p -, 2 ,aiid %,.
oMily cotsider those. so the 0ýt iniate (3) appliv'' to thllis caa ako. Itieqiality, 30, 1- a
cotisequeitco of Stirlinv'- formula '11. M

Definition 3.1 Lt z' =ip.,, bh the minitnum number of point,, per tavleiie1
thatlI-
needed to niakv 1.agrantg ittterpi lotIis, formula of order p approxiniat,' with a(, ur& III
the function.l

- 2-, Wit I - .1 ,,u

m - 1 and - A - I/ N

inside the central h, b\ III re(tangle of thi itit.rpslati,.ti & "id 1 . Sj. U

Remark 3.3 hn order to a.,,uro t hat I.agranve inirpol.t i,ol ha lira, \-. ',s Ii,, ,
the paraTiI ter- p and I'. defiried in eqttatiots I I atld l1),'tsitIP,,t 3.. ,'',' ,.ls I ,,.w ,.I
l)efinition 3.1. we ,., the, aniaplipht ieterval- I,, aid III ,io b-,:

it -
-
---
a
adlii
r,
1h
h ,
--- I 3

Substituting, 37) into (36). we sev that

i_R; [,2? /,,.If 17+(2 +

_ 21

Niimieical evidence sugssthat v, =) p' a goodlcoc' Mak-ing 1111- 111u 3i 'A

see that Lagrange interpolatilot ik guaranteed to have, aceiracy , if

Consequently. we choose paramete rs p ard I, of the conpiput at ijeri arc•,rdinig , thii r11lw
t

2v p --- log-.- 10

Numerical experiments of Section 5. however. sl40% that the req lii r•,ivitt I1T, I- uid u,,
strict. For example. for f = 10-14, theIt itpqialit v (39) detnands p = 27-). %%hil p ý lIf I-
sufficient. Similarly. for single precision. , -7.
- thI inequali
; , 1,I 1 requr, ' 1
when. in fact. p = 10 is large enough. U

9
 With the help of the lemmas 3.1 and 3.2 we can now estimate the total error of the
computation. 0
Substituting (34) intc (23), we get:
q1 P P
jFmn,(x.y)dy = E :1 Zbj 2 .
(V4)*Fmti. . 3 k -b.~
k
k=1 j1=1 32=1

E , 1(F
+ o -
mn, +( +) bt-P-) , (41)
k=1

Denoting by Rp the right-hand side of (36), by /Eq the right-hand side of (24), and, observing
that Z- = 1 = 1, we see that the error of integrating along the path -I- in (41) is bounded
by 0
bkql + bRp < 2bf < 2L(, (42)

if p and v are chosen according to relations (40) in Remark 3.3.

Summing up the errors in (42) over all paths -y) that form the boundary F,. we see that
integration around each F, results in an error not greater than

2(11r, 11.
where 117t denotes the length of the perimeter of F,. The total error of the computation
is, therefore, at most
J
2( Kj - 117 II.
11
j=1

Actual errors are reported in Section .5.

4 Formal Description of the Algorithm

4.1 Description of the Algorithm

Let f : R 2 , C'V be as in (13), and M and N be the highest frequencies desired in the
Fourier transform of f along the z- and y-axis, respectively.
STEP 0: INITIALIZATION.
Comment: [ We choose precision of the computation ( and determine the degree of
Lagrange interpolation p and the oversampling factor v as described in Remark 3.3.
Since we will need v points per wavelength, we create the function G(m, "), defined in
(21), on the uniform grid on [0, 1] x [0, 1] with the sampling intervals h. = 1/(vM) and
hy = 1/(vN). We will also make use of a one-dimensional array Go(n) to compute the
Fourier Transform for the case m = 0. We precompute the denominators of Lagrange
interpolation and Gauss-Legendre nodes and weights on [0, 1].

10

0_
O0. 0 0
O0... . 0.. 0, 0 0 4
 I

do n =1...vN
Go(n) 0
do in =1...VM
G(m,n) = 0 4
enddo
enddo

STEP 1: GREEN'S THEOREM AND LAGRANGE INTERPOLATION.

Comment: [ For each j, we integrate the constant function Kj along each of the paths
7• : [0, 1] - r,, defined in (14), and then redistribute the weight from each of the re-
sulting Gauss-Legendre nodes to p2 Lagrange nodes from the uniform grid as described
in equation (19). Note: The double index (m(il), n(i 2)) of the array G corresponds to
the point (X, 1 , Yi2 ). ]

do j= 1. J
do l=. L
Using the precomputed nodes and weights on [0, 1) calculate the Gauss-
Legendre nodes {(X , V,' )) and weights w, (defined in (18)) needed to com-
pute the line integrals along -y.
do k = 1.
doi=1. pandi 2 =1. p
G(m(i 1 ).n(i2 )) = G(m(il), n(i 2 )) + K" b..,k4 bi, ) 6,(t.)
Go(n(i 2 )) = Go(n(i 2 ))+ KJ , X1 b .6,,(x1".6 ,(v)
k k
enddo
enddo
enddo
enddo
STEP 2: FOURIER TRANSFORM.
Comment: [ We apply the two-dimensional FFT to the vM by vN array G and only
keep the frequencies (rnn) with -M < in < M and -N < n < N. We store the
result in the array FG. Similarly, we apply the one-dimensional FFT to the array
G0 . keep only the frequencies n with -AN < n < N, and store the result in the array
FGo.]

STEP 3: INTEGRATION.
Comment: [ For each frequency (m, n) with in $ 0, we divide its coefficient by -2frim,
which brings the computation in agreement with equation (19). The case in = 0 is al-
ready correct and needs no adjustment. I

dom=-M+ 1,...,M andn = -N+ 1.....N: with mi 0 5

FG(n, n) = FG(rn, n)/(-27rim)
enddo
don = -N+ E.... N
FG(O, n) = FGo(n)
enddo 5

dL _O__
• ___
O._• •• I • •
Remark 4.1 Often. for example in VLSI modeling, the boundaries of the domains D, con-
tain vertical and horizontal straight-line segments. Contribution from horizontal segments
to (15) is zero, and if S is a vertical segment from (xo, yo) to (xo, yl), then, for n $ 0.
F,..,,(x, y) d = Fm,,(xo,
.... y ) - F,,(xo, yo) (43)
-27rin

that is, computation of a line integral is replaced by evaluation of a sum of two terms of
the same type as in the approximation (17). Effects of the resulting speed-up are discussed
in Section 5. a

4.2 Complexity Analysis of the Algorithm

Time complexity of the algorithm is summarised in Table 1. We assume in this section, for
convenience, that Al = N.

STEP 1 p2 N'g N. is the number of Gauss-

Legendre nodes created.
STEP 2 O(v 2N 2 log N + vN logN) One two-dimensional and one
one-dimensional FFT.
STEP 3 O(N 2) Division of each Fourier coeffi-
I cient FG(m,n) by -2irirn.

Table 1: Time complexity of the algorithm.

For a given accuracy ( the number of Gauss-Legendre nodes on a single path 1', accord-
ing to Corollary 3.1, is

where M is the highest frequency along 1' and L is the length of If as described in Re-
mark 3.2. Since M = N. M = N. Therefore. the number of nodes needed for [. is:

0 max v~INrjII,.1,L, -log}) (45)

where 1ir,11 is the length of F,, and L, is the number of the paths -y' that form Fr. It follows
that the total number of nodes, Ng, satisfies the relation:

N9 = 0 max N .• JFIII, L) -log} . (46)

In the worst case, i.e., when the perimeter is largest, there are O(N 2 ) domains D, with
diameter 0(1/N ) each. N9 , then, becomes

N 9 =O(max{N'N2 ' N2 'log!})" (47)

12

!
Choosing parameters p and v according to (40), i.e., with

2v = p , log-, (48) 0

we arrive at a bound for time complexity of the algorithm: 4

O(p 2 Ng+ v 2 N 2 logN + N2 )= 0 ((log3i) N2 + (log1 ) N 2 log N). (49)

5 Numerical Experiments
We implemented the algorithm of section 4 both with and without the observation about the
Green's theorem in §2.2. The algorithm was implemented in FORTRAN 77 and was run on
SPARCstation 2. All internal calculations were performed in double-precision arithmetic,
but the parameters p and v were relaxed for single-precision experiments. Accuracy was
measured in the cases when all domains were rectangles; in these cases exact analytic
solution is available and it was computed in double-precision for comparison. To assure
that integration along more general curves does not introduce unexpected errors, we cut
the rectangles into more complicated shapes (thus preserving the final answer) and verified
that the error did not increase. This suggests that the error is not higher for the regions
for which closed form solutions are not available.
In the tables below we report the results of numerical experiments using the following
three algorithms. In Algorithm I we make use of the Green's theorem as described in
the preceding sections and, in addition, make use of Remark 4.1 to integrate along thp
horizontal and vertical lines. Algorithm 2 is also based on the Green's theorem, but without * *
preferential treatment for horizontal or vertical lines. In Algorithm 3 the area integrals are
treated directly without recourse to the Green's theorem.
When all the domains {Dj} are rectangles. we report run times for a direct method,
which we also use to estimate the errors of the computations. When, for each j, D, =
(a]. b,) X (c), dj), the direct method consists of calculating the Fourier transform, O: 2 -
C(. by evaluating the Fourier integrals analytically:

( m. n) = E jb j 2
- 7rtmxC-21riny dydx
a3 Cj

E -2=rim6x - i(mn) - i(m

,na -C.
-5) r

Z
- -21rim -2,rin

The error E,, that we report is the maximal absolute error among all the frequencies:

E. max lf(mn,n)- 0(m,n)j. (50)

We do not report results for Algorithm 3 with N = 256 because its memory requirements
were excessive for our implementation.
In the examples I and 2 we also include the performance of the standard FFT. These
results are for illustrative purposes only; they can be improved with the help of some
standard techniques such as Richardson extrapolation.

13

• .. . • • •• • •

00 I IIII IIII 0 0 0 *,
Example 1 Here we compute the Fourier Transform of a single large rectangle (approx- U
imately 0.6 by 0.66). Extrapolating the results for the FFT, we see that single precision S
accuracy, E. , = 10-7, would result in time complexity of more than 109 operations, and
for double precision we would need more than 1023.

Example 2 In this and the next example we calculate the Fourier transforms of a piece
of a VLSI mask (courtesy of Eytan Barouch). In simulations, these masks usually consist
of a large number of simple geometric shapes that model the integrated circuit. In our
case, there are 1215 rectangles and 424 triangles. In this example we compute the Fourier
transform of the rectangles only in order to estimate the error of the computation. In the
next example, we calculate the Fourier transform of all the domains, including the triangles.
The results of this example can be found in tables 4 and 5, and those of example 3 in table 6.

Example 3 In this example we compute the Fourier Transform of 1215 small rectangles
(the same ones as in the previous example) and 424 triangles. Their total area is 0.183 and
the total perimeter of their union is 69.3. The total perimeter of the domains in this example
(and, consequently, the run times of algorithms 1 and 2) are slightly smaller than in the
previous example because some of the newly-added triangles share some of their boundaries
with the rectangles. (We remove from the computation the curves whose contributions can
be easily seen to cancel.)

The following observations can be made based on the numerical experiments above:

1. The errors for all three algorithms do not grow with N-the size of the problem.
2. All three algorithms have approximately the same accuracy.
3. The run times grow approximately like N 2 in example 1 for all three algorithms, and
in example 2 for algorithms 1 and 3 (in agreement with (49)), while the run times for
Algorithm 2 in example 2 appear to grow linearly. This apparent linear growth is the
result of the large number N. of Gauss-Legendre nodes generated, causing Lagrange
interpolation to dominate the computation. Since N_, grows linearly with N, the total
run times appear to grow linearly as well. The timings for Algorithm I in example 2
grow quadratically because FFT dominates the computation. On the other hand, in
Algorithm 3 in example 2 Lagrange interpolation dominates the computation, but N.,
in this case grows quadratically, so the overall growth remains quadratic. The VLSI
mask of example 3 cannot be handled with the method of Remark 4.1 alone: some line
integrals need to .e computed numerically. As a result the run times of Algorithm I
in example 3 grow at an intermediate rate.

4. Algorithm 2 is significantly faster than Algorithm 3, even when the ratio of perimeter
to area is large. But Algorithm 1 is only twice as fast as Algorithm 2 on realistic
problems (examples 2 and 3). On the same realistic problems all three algorithms are
faster (for N > 64) than the closed form solution even when it is available. When the
closed form solution is not available, straightforward calculations are prohibitively
slow: single precision would require at least 150 years and double precision over

14
 S
X)

Double Precision: p =16 and v =8

Run times (seconds) The error E,, ____

N Aig. 1 Aig. 2 Aig. 3 FIFT Direct Aig. 1 Alg. 2 Alg. 3 FET

16 2.3 3.7 129 0.1 0.2 4.8e- 15 6.3e- 15 6.3e- 15 4.0e-02
32 11.1 14.2 671 0.2 0.8 4.6e- 15 4.6e- 15 3.3e- 15 2.3e-02
64 52.0 57.1 2755 0.5 3.0 2.Oe- 15 2.0e- 15 1.6e- 15 9.2e-03
128 208.0 222.0 11112 2.0 12.2 l.Oe- 15 1.le-15 1.le-15 5.0e-03
256 1000.0 1028.0 ____ 8.7 48.6 l .Oe- 15 1.2e- 15 ____2.5e-03

Table 2: Run times and errors for example 1; double precision. /

15i
Single Precision: p =10 and v' =~ 5 0
Run times (seconds) The errorE, S
N Alg. 1 Alg. 2 Alg. 3 FFT Direct Aig. 1 Aig. 2 Aig. 3 FF1
16 0.9 1.3 24 0.1 0.2 1.7e-08 1.5e-08 1.5e-08 4.0e-02
32 3.9 4.7 95 0.2 0.7 8.5e-09 8.3e-09 7.7e-09 2.3e-02
64 18.4 20.1 381 0.5 3.1 5.2e-09 4.7e-09 4.8e-09 9.2e-03 10
128 83.3 86.4 1538 2.0 12.2 2.0e-09 5.7e-09 4.3e-09 5.0e-03
256 339.0 ,345.0 ____ 8.7 48.6 1.5e-09 4.4e-09 2.5e-03

Table 3: Run times and errors for example 1; single precision.

016 0. . 2 0. 0. 48e5 0.e1 6.e 04.00-0

1I
 6

i
4'

Double Precision: p = 16 and v = 8

Run times (seconds) The error E,
N Alg. 1 Alg. 2 Alg. 3 FFT Direct Alg. 1 Alg. 2 Alg. 3 FFT
16 6.4 77 283 3.1 165 1.le-14 1.Oe-14 5.9e-15 5.7e-02
32 15.8 156 887 3.1 672 6.2e-15 9.4e-15 7.7e-15 4.2e-02
64 55.0 293 2277 3.5 2707 5.7e-15 1.le-14 5.1e-15 3.1e-02
128 213.0 643 6562 4.8 10874 3.3e-15 7.8e-15 3.5e-15 2.9e-02 S
256 1004.0 1834 11.7 43740 2.4e-15 1.Oe-14 1.7e-02

Table 4: Run times and errors for example 2; double precision.

Single Precision: p = 10 and v =5

Run times (seconds) The error E,
N Alg. I Alg. 2 Alg. 3 FFT Direct Aig. I Alg. 2 Alg. 3 FFT
16 2.9 31 94 3.1 165 2.2e-08 3.8e-08 1.3e-08 5.7e-02
32 6.0 48 190 3.1 673 2.2e-08 2.0e-08 l.Se-08 4.2e-02
64 19.6 83 398 3.5 2717 1.3e-08 4.0e-OX 1.3e-08 3.1e-02 S
128 85.2 200 1075 4.8 10920 9.2e-09 1.6e-09 9.0e-09 2.9e-02
256 33X.0 562 11.7 43630 5.3e-09 2.7e-09 1.7e-02

Table 5: Run times and errors for example 2: single precision.

Double precision: Single precision:

p= 16and v= 8 p= 10and v= 5
N Alg. I Alg. 2 Alg. 3 Alg. I Alg. 2 Alg. 3
16 11 73 333 4.2 29 107
32 23 148 989 8.1 45 216
64 65 282 2451 22.3 80 4-11
128 231 628 6972 89.7 193 1153
256 1036 1804 1 1 347.0 555

Table 6: Run times (in seconds) for example 3. 0

16

• • • ... • •.. •• €
 0

1016 years regardless of the values of N. Adjustments such as repeated Richardson

extrapolation will undoubtedly improve these times, but are unlikely to make them X"
competitive. •

6 Conclusions and Generalizations

6.1 Generalizations

The entire algorithm of Section 4, including Remark 4.1, readily generalizes to higher di-
mensions: we will not describe the details of the higher-dimensional implementation here.
We will describe an extension of the algorithm to piecewise smooth functions. If the
function f(x, y) in (13) is piecewise smooth, i.e.. for each j, the coefficient ', = K,(X, y) is
a smooth function of (x. y), we analyze it into a Fourier series with respect to x:

K,'(X.y) = k',(v)(yT '.... (51)

rn

where
k'(71)(y) hK-, (X, Of 2,,,,, dx.

We observe next that all the computations of ý3.2 continue to hold if K, is a function of y
alone. That is. the algorithm of Section 4 can be applied to ,',(m)(y) separately for each
rn and the results added up afterwards. The time complexity of this new algorithm would
be that of the algorithm of Section 4 times the width of the widest Fourier transform (in
the x-direction only) of the functions A',(x,y). S 0

6.2 Conclusions
We have presented an algorithm for evaluation of the Fourier transform of piecewise constant
functions of two variables. The algorithm overcomes the accuracy problems associated wit h1
computing the Fourier transform of discontinuous functions: in fact, its time complexity*
2
is O(log 3 ( l/f)N.og.N), where f is the accuracy and N is the size of the problem. The
algorithm is based on the Lagrange interpolation formula and the Green's theorem, which
are used to preprocess the data before applying the FFT. It admits natural generalizations
to higher dimensions and to piecewise smooth functions.

References
(1] M. Abramowitz and I. Stegun, Handbook of Mathematical Functions, (l)over. New
York, 1970).

[21 E. Oran Brigham. The Fast Fourier Transform and its Applications. (Prentice Hall,
Englewood Cliffs, NJ, 19X8).

[3] J. W. ('ooley and J. W. Tukey, An algorithm for the machine computation of complex
Fourier series. Math. ('omp. 19. (1965).

17

• • • •• • •

S .. . S ll ... In i . . . i . . 0 . 0i
 0

i
Cliffs, NJ. •
[4] G. Dahlquist and A. Bj6rck, Numerical Methods, (Prentice-Hall. Englewood
1974).

(5] D. Gottlieb, M. Y. Hussaini. and S. Orszag. in Spectral Methods for PartialDifferential

Equations, edited by R. G. Voigt, D. Gottlieb, and M. Y. Hussaini. (SIAM, Philadelphia
PA, 19841).

[6] 1. S. Gradshteyn and I. M. Ryzhik, Table of Integrals, Series, and Products, (Academic
Press, New York, 1980).

[7] J. Stoer and R. Bulirsch. Introduction to Numerical Analysis, (Springer Verlag, New
York, 1980).

[8] H. Joseph Weaver, Theory of Discrete and Continuous Fourier Analysis, (Wiley, 1989).

isS