Subversion Repositories shark

Rev

Rev 3 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 pj 1
Info file: fftw-faq.info,    -*-Text-*-
2
produced by bfnnconv.pl from the Bizarre Format With No Name.
3
 
4
START-INFO-DIR-ENTRY
5
* FFTW FAQ: (fftw-faq). FFTW Frequently Asked Questions with Answers.
6
END-INFO-DIR-ENTRY
7
 
8

9
File: $prefix.info, Node: Top, Next: Question 1.1, Up: (dir)
10
 
11
            FFTW FREQUENTLY ASKED QUESTIONS WITH ANSWERS
12
                            18 May 1999
13
			     Matteo Frigo
14
			   Steven G. Johnson
15
		       <fftw@theory.lcs.mit.edu>
16
 
17
This is the list of Frequently Asked Questions about FFTW, a collection of
18
fast C routines for computing the Discrete Fourier Transform in one or
19
more dimensions.
20
 
21
Index
22
 
23
* Menu:
24
* Section 1::       Introduction and General Information
25
* Section 2::       Installing FFTW
26
* Section 3::       Using FFTW
27
* Section 4::       Internals of FFTW
28
* Section 5::       Known bugs
29
 
30
Section 1, Introduction and General Information
31
* Question 1.1::    What is FFTW?
32
* Question 1.2::    How do I obtain FFTW?
33
* Question 1.3::    Is FFTW free software?
34
* Question 1.4::    What is this about non-free licenses?
35
 
36
Section 2, Installing FFTW
37
* Question 2.1::    Which systems does FFTW run on?
38
* Question 2.2::    Does FFTW run on DOS/Windows?
39
* Question 2.3::    My compiler crashes when compiling FFTW.
40
* Question 2.4::    FFTW does not compile on Solaris, complaining about
41
                    const.
42
* Question 2.5::    Which language is FFTW written in?
43
* Question 2.6::    Can I call FFTW from FORTRAN?
44
* Question 2.7::    Can I call FFTW from C++?
45
* Question 2.8::    Why isn't FFTW written in FORTRAN/C++?
46
* Question 2.9::    How do I compile FFTW to run in single precision?
47
 
48
Section 3, Using FFTW
49
* Question 3.1::    FFTW seems really slow.
50
* Question 3.2::    FFTW gives results different from my old FFT.
51
* Question 3.3::    Can I save FFTW's plans?
52
* Question 3.4::    Why does your inverse transform return a scaled
53
                    result?
54
* Question 3.5::    How can I make FFTW put the origin (zero frequency) at
55
                    the center of its output?
56
* Question 3.6::    How do I FFT an image/audio file in *foobar* format?
57
* Question 3.7::    My program does not link (on Unix).
58
 
59
Section 4, Internals of FFTW
60
* Question 4.1::    How does FFTW work?
61
* Question 4.2::    Why is FFTW so fast?
62
* Question 4.3::    What is this wisdom thing?
63
* Question 4.4::    Why do you use wisdom? I just wanted to save a plan.
64
 
65
Section 5, Known bugs
66
* Question 5.1::    FFTW 1.1 crashes in rfftwnd on Linux.
67
* Question 5.2::    The MPI transforms in FFTW 1.2 give incorrect
68
                    results/leak memory.
69
* Question 5.3::    The test programs in FFTW 1.2.1 fail when I change
70
                    FFTW to use single precision.
71
* Question 5.4::    The test program in FFTW 1.2.1 fails for n > 46340.
72
* Question 5.5::    The threaded code fails on Linux Redhat 5.0
73
* Question 5.6::    FFTW 2.0's rfftwnd fails for rank > 1 transforms with
74
                    a final dimension >= 65536.
75
* Question 5.7::    FFTW 2.0's complex transforms give the wrong results
76
                    with prime factors 17 to 97.
77
* Question 5.8::    FFTW 2.1.1's MPI test programs crash with MPICH.
78
 
79
 
80

81
File: fftw-faq.info, Node: Section 1, Next: Section 2, Previous: Top, Up: Top
82
 
83
Introduction and General Information
84
 
85
* Menu:
86
* Question 1.1::    What is FFTW?
87
* Question 1.2::    How do I obtain FFTW?
88
* Question 1.3::    Is FFTW free software?
89
* Question 1.4::    What is this about non-free licenses?
90
 
91
 
92

93
File: fftw-faq.info, Node: Question 1.1, Next: Question 1.2, Previous: Top, Up: Section 1
94
 
95
Question 1.1.  What is FFTW?
96
 
97
FFTW is a free collection of fast C routines for computing the Discrete
98
Fourier Transform in one or more dimensions.  It includes complex, real,
99
and parallel transforms, and can handle arbitrary array sizes efficiently.
100
FFTW is typically faster than other publically-available FFT
101
implementations, and is even competitive with vendor-tuned libraries.
102
(See our web page for extensive benchmarks.) To achieve this performance,
103
FFTW uses novel code-generation and runtime self-optimization techniques
104
(along with many other tricks).
105
 
106

107
File: fftw-faq.info, Node: Question 1.2, Next: Question 1.3, Previous: Question 1.1, Up: Section 1
108
 
109
Question 1.2.  How do I obtain FFTW?
110
 
111
FFTW can be found at the FFTW web page.  You can also retrieve it from
112
theory.lcs.mit.edu in /pub/fftw.
113
 
114

115
File: fftw-faq.info, Node: Question 1.3, Next: Question 1.4, Previous: Question 1.2, Up: Section 1
116
 
117
Question 1.3.  Is FFTW free software?
118
 
119
Starting with version 1.3, FFTW is Free Software in the technical sense
120
defined by the Free Software Foundation (see Categories of Free and
121
Non-Free Software), and is distributed under the terms of the GNU General
122
Public License.  Previous versions of FFTW were distributed without fee
123
for noncommercial use, but were not technically ``free.''
124
 
125
Non-free licenses for FFTW are also available that permit different terms
126
of use than the GPL.
127
 
128

129
File: fftw-faq.info, Node: Question 1.4, Next: Question 2.1, Previous: Question 1.3, Up: Section 1
130
 
131
Question 1.4.  What is this about non-free licenses?
132
 
133
The non-free licenses are for companies that wish to use FFTW in their
134
products but are unwilling to release their software under the GPL (which
135
would require them to release source code and allow free redistribution).
136
Such users can purchase an unlimited-use license from MIT.  Contact us for
137
more details.
138
 
139
We could instead have released FFTW under the LGPL, or even disallowed
140
non-Free usage.  Suffice it to say, however, that MIT owns the copyright
141
to FFTW and they only let us GPL it because we convinced them that it
142
would neither affect their licensing revenue nor irritate existing
143
licensees.
144
 
145

146
File: fftw-faq.info, Node: Section 2, Next: Section 3, Previous: Section 1, Up: Top
147
 
148
Installing FFTW
149
 
150
* Menu:
151
* Question 2.1::    Which systems does FFTW run on?
152
* Question 2.2::    Does FFTW run on DOS/Windows?
153
* Question 2.3::    My compiler crashes when compiling FFTW.
154
* Question 2.4::    FFTW does not compile on Solaris, complaining about
155
                    const.
156
* Question 2.5::    Which language is FFTW written in?
157
* Question 2.6::    Can I call FFTW from FORTRAN?
158
* Question 2.7::    Can I call FFTW from C++?
159
* Question 2.8::    Why isn't FFTW written in FORTRAN/C++?
160
* Question 2.9::    How do I compile FFTW to run in single precision?
161
 
162
 
163

164
File: fftw-faq.info, Node: Question 2.1, Next: Question 2.2, Previous: Question 1.4, Up: Section 2
165
 
166
Question 2.1.  Which systems does FFTW run on?
167
 
168
FFTW is written in ANSI C, and should work on any system with a decent C
169
compiler.  (See also *Note Question 2.2:: `Does FFTW run on DOS/Windows?'
170
and  *Note Question 2.3:: `My compiler crashes when compiling FFTW.'.)
171
 
172

173
File: fftw-faq.info, Node: Question 2.2, Next: Question 2.3, Previous: Question 2.1, Up: Section 2
174
 
175
Question 2.2.  Does FFTW run on DOS/Windows?
176
 
177
It should.  FFTW was not developed on DOS or Windows, but the source code
178
is straight ANSI C.  Some users have reported using FFTW on DOS/Windows
179
using various compilers.  See also the FFTW Windows installation notes and
180
*Note Question 2.3:: `My compiler crashes when compiling FFTW.'
181
 
182

183
File: fftw-faq.info, Node: Question 2.3, Next: Question 2.4, Previous: Question 2.2, Up: Section 2
184
 
185
Question 2.3.  My compiler crashes when compiling FFTW.
186
 
187
Complain fiercely to the vendor of the compiler.
188
 
189
FFTW is a heavily-optimized piece of software that is likely to push
190
compilers to their limits.  We had no problems with, for example, gcc
191
2.7.2, Sun's SC4.0, IBM's XLC, Metrowerks' compilers for the Macintosh,
192
and SGI's compilers for IRIX 6.2.  Users have also reported successful
193
compilations of FFTW using Borland's C/C++ compilers on Windows.
194
 
195
Visual C++ 4.0 crashes when compiling FFTW 1.2 with all optimizations
196
turned on.  Visual C++ 5.0 reportedly produces incorrect code for the real
197
transforms in FFTW 2.x when the option "Maximize speed" is set.  We are
198
told that Service Pack 3 fixes the bug.
199
 
200
Various problems have also been observed with SGI's MIPSpro compilers,
201
versions 7.2.0 and 7.2.1 (you may have to lower the optimization level for
202
some files to get them to compile).  The test program in earlier versions
203
of FFTW had problems with the -xO5 option in Sun's SC4.0 C compiler.
204
 
205

206
File: fftw-faq.info, Node: Question 2.4, Next: Question 2.5, Previous: Question 2.3, Up: Section 2
207
 
208
Question 2.4.  FFTW does not compile on Solaris, complaining about const.
209
 
210
We know that at least on Solaris 2.5.x with Sun's compilers 4.2 you might
211
get error messages from make such as
212
 
213
"./fftw.h", line 88: warning: const is a keyword in ANSI C
214
 
215
This is the case when the configure script reports that const does not
216
work:
217
 
218
checking for working const... (cached) no
219
 
220
You should be aware that Solaris comes with two compilers, namely,
221
/opt/SUNWspro/SC4.2/bin/cc and /usr/ucb/cc.  The latter compiler is
222
non-ANSI.  Indeed, it is a perverse shell script that calls the real
223
compiler in non-ANSI mode.  In order to compile FFTW, change your path so
224
that the right cc is used.
225
 
226
To know whether your compiler is the right one,  type cc -V.  If the
227
compiler prints ``ucbcc'', as in
228
 
229
ucbcc: WorkShop Compilers 4.2 30 Oct 1996 C 4.2
230
 
231
then the compiler is wrong.  The right message is something like
232
 
233
cc: WorkShop Compilers 4.2 30 Oct 1996 C 4.2
234
 
235

236
File: fftw-faq.info, Node: Question 2.5, Next: Question 2.6, Previous: Question 2.4, Up: Section 2
237
 
238
Question 2.5.  Which language is FFTW written in?
239
 
240
FFTW is written in ANSI C.  Most of the code, however, was automatically
241
generated by a program called genfft, written in the Objective Caml
242
dialect of ML.  You do not need to know ML or to have an Objective Caml
243
compiler in order to use FFTW.
244
 
245
genfft is provided with the FFTW sources, which means that you can play
246
with the code generator if you want.  In this case, you need a working
247
Objective Caml system.  Objective Caml is available from ftp.inria.fr in
248
the directory /lang/caml-light.
249
 
250

251
File: fftw-faq.info, Node: Question 2.6, Next: Question 2.7, Previous: Question 2.5, Up: Section 2
252
 
253
Question 2.6.  Can I call FFTW from FORTRAN?
254
 
255
Yes, but not directly.  The main problem is that Fortran cannot pass
256
parameters by value.  However, FFTW can be called indirectly from Fortran
257
through the use of special C "wrapper" routines.  Appropriate wrapper
258
code, documented in the FFTW manual, is included with FFTW (versions 1.3
259
and higher).
260
 
261

262
File: fftw-faq.info, Node: Question 2.7, Next: Question 2.8, Previous: Question 2.6, Up: Section 2
263
 
264
Question 2.7.  Can I call FFTW from C++?
265
 
266
Most definitely.  FFTW should compile and run under any C++ compiler.
267
 
268

269
File: fftw-faq.info, Node: Question 2.8, Next: Question 2.9, Previous: Question 2.7, Up: Section 2
270
 
271
Question 2.8.  Why isn't FFTW written in FORTRAN/C++?
272
 
273
Because we don't like those languages, and neither approaches the
274
portability of C.
275
 
276

277
File: fftw-faq.info, Node: Question 2.9, Next: Question 3.1, Previous: Question 2.8, Up: Section 2
278
 
279
Question 2.9.  How do I compile FFTW to run in single precision?
280
 
281
On a Unix system: configure --enable-float.  On a non-Unix system: edit
282
fftw/fftw.h to #define the symbol FFTW_ENABLE_FLOAT.  In both cases, you
283
must then recompile FFTW.
284
 
285

286
File: fftw-faq.info, Node: Section 3, Next: Section 4, Previous: Section 2, Up: Top
287
 
288
Using FFTW
289
 
290
* Menu:
291
* Question 3.1::    FFTW seems really slow.
292
* Question 3.2::    FFTW gives results different from my old FFT.
293
* Question 3.3::    Can I save FFTW's plans?
294
* Question 3.4::    Why does your inverse transform return a scaled
295
                    result?
296
* Question 3.5::    How can I make FFTW put the origin (zero frequency) at
297
                    the center of its output?
298
* Question 3.6::    How do I FFT an image/audio file in *foobar* format?
299
* Question 3.7::    My program does not link (on Unix).
300
 
301
 
302

303
File: fftw-faq.info, Node: Question 3.1, Next: Question 3.2, Previous: Question 2.9, Up: Section 3
304
 
305
Question 3.1.  FFTW seems really slow.
306
 
307
You are probably recreating the plan before every transform, rather than
308
creating it once and reusing it for all transforms of the same size.  FFTW
309
is designed to be used in the following way:
310
 
311
* First, you create a plan.  This will take several seconds.
312
* Then, you reuse the plan many times to perform FFTs.  These are fast.
313
If you don't need to compute many transforms and the time for the planner
314
is significant, you have two options.  First, you can use the
315
FFTW_ESTIMATE option in the planner, which uses heuristics instead of
316
runtime measurements and produces a good plan in a short time.  Second,
317
you can use the wisdom feature to precompute the plan; see *Note Question
318
3.3:: `Can I save FFTW's plans?'
319
 
320

321
File: fftw-faq.info, Node: Question 3.2, Next: Question 3.3, Previous: Question 3.1, Up: Section 3
322
 
323
Question 3.2.  FFTW gives results different from my old FFT.
324
 
325
People follow many different conventions for the DFT, and you should be
326
sure to know the ones that we use (described in the FFTW manual).  In
327
particular, you should be aware that the FFTW_FORWARD/FFTW_BACKWARD
328
directions correspond to signs of -1/+1 in the exponent of the DFT
329
definition.  (*Numerical Recipes* uses the opposite convention.)
330
 
331
You should also know that we compute an unnormalized transform.  In
332
contrast, Matlab is an example of program that computes a normalized
333
transform.  See *Note Question 3.4:: `Why does your inverse transform
334
return a scaled result?'.
335
 
336

337
File: fftw-faq.info, Node: Question 3.3, Next: Question 3.4, Previous: Question 3.2, Up: Section 3
338
 
339
Question 3.3.  Can I save FFTW's plans?
340
 
341
Yes. Starting with version 1.2, FFTW provides the  wisdom mechanism for
342
saving plans.  See *Note Question 4.3:: `What is this wisdom thing?' and
343
the FFTW manual.
344
 
345

346
File: fftw-faq.info, Node: Question 3.4, Next: Question 3.5, Previous: Question 3.3, Up: Section 3
347
 
348
Question 3.4.  Why does your inverse transform return a scaled result?
349
 
350
Computing the forward transform followed by the backward transform (or
351
vice versa) yields the original array scaled by the size of the array.
352
(For multi-dimensional transforms, the size of the array is the product of
353
the dimensions.)  We could, instead, have chosen a normalization that
354
would have returned the unscaled array. Or, to accomodate the many
355
conventions in this matter, the transform routines could have accepted a
356
"scale factor" parameter. We did not do this, however, for two reasons.
357
First, we didn't want to sacrifice performance in the common case where
358
the scale factor is 1. Second, in real applications the FFT is followed or
359
preceded by some computation on the data, into which the scale factor can
360
typically be absorbed at little or no cost.
361
 
362

363
File: fftw-faq.info, Node: Question 3.5, Next: Question 3.6, Previous: Question 3.4, Up: Section 3
364
 
365
Question 3.5.  How can I make FFTW put the origin (zero frequency) at the center of its output?
366
 
367
For human viewing of a spectrum, it is often convenient to put the origin
368
in frequency space at the center of the output array, rather than in the
369
zero-th element (the default in FFTW).  If all of the dimensions of your
370
array are even, you can accomplish this by simply multiplying each element
371
of the input array by (-1)^(i + j + ...), where i, j, etcetera are the
372
indices of the element.  (This trick is a general property of the DFT, and
373
is not specific to FFTW.)
374
 
375

376
File: fftw-faq.info, Node: Question 3.6, Next: Question 3.7, Previous: Question 3.5, Up: Section 3
377
 
378
Question 3.6.  How do I FFT an image/audio file in *foobar* format?
379
 
380
FFTW performs an FFT on an array of floating-point values.  You can
381
certainly use it to compute the transform of an image or audio stream, but
382
you are responsible for figuring out your data format and converting it to
383
the form FFTW requires.
384
 
385

386
File: fftw-faq.info, Node: Question 3.7, Next: Question 4.1, Previous: Question 3.6, Up: Section 3
387
 
388
Question 3.7.  My program does not link (on Unix).
389
 
390
Please use the exact order in which libraries are specified by the FFTW
391
manual (e.g. -lrfftw -lfftw -lm).  Also, note that the libraries must be
392
listed after your program sources/objects.  (The general rule is that if
393
*A* uses *B*, then *A* must be listed before *B* in the link command.).
394
For example, switching the order to -lfftw -lrfftw -lm will fail.
395
 
396

397
File: fftw-faq.info, Node: Section 4, Next: Section 5, Previous: Section 3, Up: Top
398
 
399
Internals of FFTW
400
 
401
* Menu:
402
* Question 4.1::    How does FFTW work?
403
* Question 4.2::    Why is FFTW so fast?
404
* Question 4.3::    What is this wisdom thing?
405
* Question 4.4::    Why do you use wisdom? I just wanted to save a plan.
406
 
407
 
408

409
File: fftw-faq.info, Node: Question 4.1, Next: Question 4.2, Previous: Question 3.7, Up: Section 4
410
 
411
Question 4.1.  How does FFTW work?
412
 
413
The innovation (if it can be so called) in FFTW consists in having an
414
interpreter execute the transform.  The program for the interpreter (the
415
*plan*) is computed at runtime according to the characteristics of your
416
machine/compiler.  This peculiar software architecture allows FFTW to
417
adapt itself to almost any machine.
418
 
419
For more details, see the paper "The Fastest Fourier Transform in the
420
West", by M. Frigo and S. G. Johnson, available at the FFTW web page.  See
421
also "FFTW: An Adaptive Software Architecture for the FFT", in ICASSP '98.
422
 
423

424
File: fftw-faq.info, Node: Question 4.2, Next: Question 4.3, Previous: Question 4.1, Up: Section 4
425
 
426
Question 4.2.  Why is FFTW so fast?
427
 
428
This is a complex question, and there is no simple answer.  In fact, the
429
authors do not fully know the answer, either.  In addition to many small
430
performance hacks throughout FFTW, there are three general reasons for
431
FFTW's speed.
432
 
433
* 	FFTW uses an internal interpreter to adapt itself to a machine.  See
434
  *Note Question 4.1:: `How does FFTW work?'.
435
* 	FFTW uses a code generator to produce highly-optimized routines for
436
  computing small transforms.
437
* 	FFTW uses explicit divide-and-conquer to take advantage of the memory
438
hierarchy.  For more details on these three topics, see the paper "The
439
Fastest Fourier Transform in the West", by M. Frigo and S. G. Johnson,
440
available at the FFTW web page.
441
 
442

443
File: fftw-faq.info, Node: Question 4.3, Next: Question 4.4, Previous: Question 4.2, Up: Section 4
444
 
445
Question 4.3.  What is this wisdom thing?
446
 
447
wisdom is the name of the mechanism that FFTW uses to save and restore
448
plans.  Rather than just saving plans, FFTW remembers what it learns about
449
your machine, and becomes wiser and wiser as time passes by.  You can save
450
wisdom for later use.
451
 
452

453
File: fftw-faq.info, Node: Question 4.4, Next: Question 5.1, Previous: Question 4.3, Up: Section 4
454
 
455
Question 4.4.  Why do you use wisdom? I just wanted to save a plan.
456
 
457
wisdom could be implemented with less effort than a general plan-saving
458
mechanism would have required.  In addition, wisdom provides additional
459
benefits.  For example, if you are planning transforms of size 1024, and
460
later you want a transform of size 2048, most of the calculations of the
461
1024 case can be reused.
462
 
463
In short, wisdom does more things with less effort, and seemed like The
464
Right Thing to do.
465
 
466

467
File: fftw-faq.info, Node: Section 5, Previous: Section 4, Up: Top
468
 
469
Known bugs
470
 
471
* Menu:
472
* Question 5.1::    FFTW 1.1 crashes in rfftwnd on Linux.
473
* Question 5.2::    The MPI transforms in FFTW 1.2 give incorrect
474
                    results/leak memory.
475
* Question 5.3::    The test programs in FFTW 1.2.1 fail when I change
476
                    FFTW to use single precision.
477
* Question 5.4::    The test program in FFTW 1.2.1 fails for n > 46340.
478
* Question 5.5::    The threaded code fails on Linux Redhat 5.0
479
* Question 5.6::    FFTW 2.0's rfftwnd fails for rank > 1 transforms with
480
                    a final dimension >= 65536.
481
* Question 5.7::    FFTW 2.0's complex transforms give the wrong results
482
                    with prime factors 17 to 97.
483
* Question 5.8::    FFTW 2.1.1's MPI test programs crash with MPICH.
484
 
485
 
486

487
File: fftw-faq.info, Node: Question 5.1, Next: Question 5.2, Previous: Question 4.4, Up: Section 5
488
 
489
Question 5.1.  FFTW 1.1 crashes in rfftwnd on Linux.
490
 
491
This bug was fixed in FFTW 1.2.  There was a bug in rfftwnd causing an
492
incorrect amount of memory to be allocated.  The bug showed up in Linux
493
with libc-5.3.12 (and nowhere else that we know of).
494
 
495

496
File: fftw-faq.info, Node: Question 5.2, Next: Question 5.3, Previous: Question 5.1, Up: Section 5
497
 
498
Question 5.2.  The MPI transforms in FFTW 1.2 give incorrect results/leak memory.
499
 
500
These bugs were corrected in FFTW 1.2.1.  The MPI transforms (really, just
501
the transpose routines) in FFTW 1.2 had bugs that could cause errors in
502
some situations.
503
 
504

505
File: fftw-faq.info, Node: Question 5.3, Next: Question 5.4, Previous: Question 5.2, Up: Section 5
506
 
507
Question 5.3.  The test programs in FFTW 1.2.1 fail when I change FFTW to use single precision.
508
 
509
This bug was fixed in FFTW 1.3.  (Older versions of FFTW did work in
510
single precision, but the test programs didn't--the error tolerances in
511
the tests were set for double precision.)
512
 
513

514
File: fftw-faq.info, Node: Question 5.4, Next: Question 5.5, Previous: Question 5.3, Up: Section 5
515
 
516
Question 5.4.  The test program in FFTW 1.2.1 fails for n > 46340.
517
 
518
This bug was fixed in FFTW 1.3.  FFTW 1.2.1 produced the right answer, but
519
the test program was wrong.  For large n, n*n in the naive transform that
520
we used for comparison overflows 32 bit integer precision, breaking the
521
test.
522
 
523

524
File: fftw-faq.info, Node: Question 5.5, Next: Question 5.6, Previous: Question 5.4, Up: Section 5
525
 
526
Question 5.5.  The threaded code fails on Linux Redhat 5.0
527
 
528
We had problems with glibc-2.0.5.  The code should work with glibc-2.0.7.
529
 
530

531
File: fftw-faq.info, Node: Question 5.6, Next: Question 5.7, Previous: Question 5.5, Up: Section 5
532
 
533
Question 5.6.  FFTW 2.0's rfftwnd fails for rank > 1 transforms with a final dimension >= 65536.
534
 
535
This bug was fixed in FFTW 2.0.1.  (There was a 32-bit integer overflow
536
due to a poorly-parenthesized expression.)
537
 
538

539
File: fftw-faq.info, Node: Question 5.7, Next: Question 5.8, Previous: Question 5.6, Up: Section 5
540
 
541
Question 5.7.  FFTW 2.0's complex transforms give the wrong results with prime factors 17 to 97.
542
 
543
There was a bug in the complex transforms that could cause incorrect
544
results under (hopefully rare) circumstances for lengths with
545
intermediate-size prime factors (17-97).  This bug was fixed in FFTW
546
2.1.1.
547
 
548

549
File: fftw-faq.info, Node: Question 5.8, Previous: Question 5.7, Up: Section 5
550
 
551
Question 5.8.  FFTW 2.1.1's MPI test programs crash with MPICH.
552
 
553
This was fixed in FFTW 2.1.2.  The 2.1/2.1.1 MPI test programs crashed
554
when using the MPICH implementation of MPI with the ch_p4 device (TCP/IP);
555
the transforms themselves worked fine.  (The source of the bug was some
556
strange constraints that MPICH imposes on access to the program argument
557
list.)
558