Rev 2 | 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 |