Hi, The attached file is the updated diff for my fftw3 3.1.2-3.1 NMU. The associated changelog entry is:
fftw3 (3.1.2-3.1) unstable; urgency=medium
* Non-maintainer upload.
* Fix bashism in debian/rules (Closes: #478376)
* debian/control:
- Add ${shlibs:Depends} to binary Depends of libfftw3-dev to satisfy
libc dependency for test and utility programs.
- Bump Standards-Version to 3.8.0
Regards,
--
Chris Lamb, UK [EMAIL PROTECTED]
GPG: 0x634F9A20
diff -Nru fftw3-3.1.2/debian/changelog fftw3-3.1.2/debian/changelog
--- fftw3-3.1.2/debian/changelog 2008-06-07 18:41:34.000000000 +0100
+++ fftw3-3.1.2/debian/changelog 2008-06-07 18:41:35.000000000 +0100
@@ -1,3 +1,14 @@
+fftw3 (3.1.2-3.1) unstable; urgency=medium
+
+ * Non-maintainer upload.
+ * Fix bashism in debian/rules (Closes: #478376)
+ * debian/control:
+ - Add ${shlibs:Depends} to binary Depends of libfftw3-dev to satisfy
+ libc dependency for test and utility programs.
+ - Bump Standards-Version to 3.8.0
+
+ -- Chris Lamb <[EMAIL PROTECTED]> Sat, 07 Jun 2008 17:59:46 +0100
+
fftw3 (3.1.2-3) unstable; urgency=low
* Rename fftw3{,-dev,-doc} to libfftw3{,-dev,-doc}.
diff -Nru fftw3-3.1.2/debian/control fftw3-3.1.2/debian/control
--- fftw3-3.1.2/debian/control 2008-06-07 18:41:34.000000000 +0100
+++ fftw3-3.1.2/debian/control 2008-06-07 18:41:35.000000000 +0100
@@ -4,7 +4,7 @@
Maintainer: Paul Brossier <[EMAIL PROTECTED]>
Build-Depends: gfortran, debhelper (>=4.0.0)
Build-Depends-Indep: transfig, texinfo, gs-gpl
-Standards-Version: 3.7.2
+Standards-Version: 3.8.0
Package: libfftw3-3
Architecture: any
@@ -27,7 +27,7 @@
Package: libfftw3-dev
Architecture: any
Section: libdevel
-Depends: libfftw3-3 (=${binary:Version})
+Depends: libfftw3-3 (=${binary:Version}), ${shlibs:Depends}
Provides: fftw3-dev
Replaces: fftw3-dev
Conflicts: fftw3-dev
diff -Nru fftw3-3.1.2/debian/rules fftw3-3.1.2/debian/rules
--- fftw3-3.1.2/debian/rules 2008-06-07 18:41:34.000000000 +0100
+++ fftw3-3.1.2/debian/rules 2008-06-07 18:41:35.000000000 +0100
@@ -100,7 +100,7 @@
-rm -f *.la threads/*.la *.pc
-rm -f test_long_long-double
-rm -f config.cache config.status config.log
- -rm -rf debian/tmp-{single,double,long-double}
+ -rm -rf debian/tmp-single debian/tmp-double debian/tmp-long-double
chmod -R g-s .
dh_clean
diff -Nru fftw3-3.1.2/doc/fftw3.info fftw3-3.1.2/doc/fftw3.info
--- fftw3-3.1.2/doc/fftw3.info 2006-07-02 21:49:05.000000000 +0100
+++ fftw3-3.1.2/doc/fftw3.info 2008-06-07 18:41:35.000000000 +0100
@@ -1,6 +1,6 @@
-This is fftw3.info, produced by makeinfo version 4.8 from fftw3.texi.
+This is fftw3.info, produced by makeinfo version 4.11 from fftw3.texi.
- This manual is for FFTW (version 3.1.2, 23 June 2006).
+This manual is for FFTW (version 3.1.2, 23 June 2006).
Copyright (C) 2003 Matteo Frigo.
@@ -20,7 +20,7 @@
modified versions, except that this permission notice may be
stated in a translation approved by the Free Software Foundation.
-INFO-DIR-SECTION Texinfo documentation system
+INFO-DIR-SECTION Development
START-INFO-DIR-ENTRY
* fftw3: (fftw3). FFTW User's Manual.
END-INFO-DIR-ENTRY
@@ -273,20 +273,20 @@
The rest of this manual is organized as follows. We first discuss
the sequential (single-processor) implementation. We start by
-describing the basic interface/features of FFTW in *Note Tutorial::.
-The following chapter discusses *Note Other Important Topics::,
-including *Note Data Alignment::, the storage scheme of
+describing the basic interface/features of FFTW in *note Tutorial::.
+The following chapter discusses *note Other Important Topics::,
+including *note Data Alignment::, the storage scheme of
multi-dimensional arrays (*note Multi-dimensional Array Format::), and
FFTW's mechanism for storing plans on disk (*note Words of
-Wisdom-Saving Plans::). Next, *Note FFTW Reference:: provides
+Wisdom-Saving Plans::). Next, *note FFTW Reference:: provides
comprehensive documentation of all FFTW's features. Parallel
-transforms are discussed in their own chapter *Note Parallel FFTW::.
-Fortran programmers can also use FFTW, as described in *Note Calling
-FFTW from Fortran::. *Note Installation and Customization:: explains
+transforms are discussed in their own chapter *note Parallel FFTW::.
+Fortran programmers can also use FFTW, as described in *note Calling
+FFTW from Fortran::. *note Installation and Customization:: explains
how to install FFTW in your computer system and how to adapt FFTW to
-your needs. License and copyright information is given in *Note
+your needs. License and copyright information is given in *note
License and Copyright::. Finally, we thank all the people who helped
-us in *Note Acknowledgments::.
+us in *note Acknowledgments::.
File: fftw3.info, Node: Tutorial, Next: Other Important Topics, Prev:
Introduction, Up: Top
@@ -307,9 +307,9 @@
not the _whole_ truth. Specifically, FFTW implements additional
routines and flags that are not documented here, although in many cases
we try to indicate where added capabilities exist. For more complete
-information, see *Note FFTW Reference::. (Note that you need to
+information, see *note FFTW Reference::. (Note that you need to
compile and install FFTW before you can use it in a program. For the
-details of the installation, see *Note Installation and
+details of the installation, see *note Installation and
Customization::.)
We recommend that you read this tutorial in order.(1) At the least,
@@ -317,7 +317,7 @@
reading any of the others, even if your main interest lies in one of
the other transform types.
- Users of FFTW version 2 and earlier may also want to read *Note
+ Users of FFTW version 2 and earlier may also want to read *note
Upgrading from FFTW version 2::.
---------- Footnotes ----------
@@ -427,7 +427,7 @@
Users should note that FFTW computes an _unnormalized_ DFT. Thus,
computing a forward followed by a backward transform (or vice versa)
results in the original array scaled by `n'. For the definition of the
-DFT, see *Note What FFTW Really Computes::.
+DFT, see *note What FFTW Really Computes::.
If you have a C compiler, such as `gcc', that supports the recent
C99 standard, and you `#include <complex.h>' _before_ `<fftw3.h>', then
@@ -445,7 +445,7 @@
Many more flags exist besides `FFTW_MEASURE' and `FFTW_ESTIMATE'.
For example, use `FFTW_PATIENT' if you're willing to wait even longer
for a possibly even faster plan (*note FFTW Reference::). You can also
-save plans for future use, as described by *Note Words of Wisdom-Saving
+save plans for future use, as described by *note Words of Wisdom-Saving
Plans::.
@@ -478,7 +478,7 @@
`n[rank-1]' transform. All of these transforms operate on contiguous
arrays in the C-standard "row-major" order, so that the last dimension
has the fastest-varying index in the array. This layout is described
-further in *Note Multi-dimensional Array Format::.
+further in *note Multi-dimensional Array Format::.
You may have noticed that all the planner routines described so far
have overlapping functionality. For example, you can plan a 1d or 2d
@@ -494,7 +494,7 @@
interfaces, which allow one to efficiently combine multiple/strided
transforms into a single FFTW plan, transform a subset of a larger
multi-dimensional array, and/or to handle more general complex-number
-formats. For more information, see *Note FFTW Reference::.
+formats. For more information, see *note FFTW Reference::.
File: fftw3.info, Node: One-Dimensional DFTs of Real Data, Next:
Multi-Dimensional DFTs of Real Data, Prev: Complex Multi-Dimensional DFTs,
Up: Tutorial
@@ -837,7 +837,7 @@
`NULL'). Otherwise, any positive `n' is supported.
For the precise mathematical definitions of these transforms as used
-by FFTW, see *Note What FFTW Really Computes::. (For people accustomed
+by FFTW, see *note What FFTW Really Computes::. (For people accustomed
to the DCT/DST, FFTW's definitions have a coefficient of 2 in front of
the cos/sin functions so that they correspond precisely to an even/odd
DFT of size N. Some authors also include additional multiplicative
@@ -932,7 +932,7 @@
Hao and R. N. Bracewell, Proc. IEEE 75, 264-266 (1987)].
For the precise mathematical definition of the DHT as used by FFTW,
-see *Note What FFTW Really Computes::.
+see *note What FFTW Really Computes::.
---------- Footnotes ----------
@@ -1262,7 +1262,7 @@
void fftw_forget_wisdom(void);
Wisdom can be exported to a file, a string, or any other medium.
-For details, see *Note Wisdom::.
+For details, see *note Wisdom::.
File: fftw3.info, Node: Caveats in Using Wisdom, Prev: Words of
Wisdom-Saving Plans, Up: Other Important Topics
@@ -1464,7 +1464,7 @@
interface. *Note Guru Interface::.
`fftw_execute' (and equivalents) is the only function in FFTW
-guaranteed to be thread-safe; see *Note Thread safety::.
+guaranteed to be thread-safe; see *note Thread safety::.
This function:
void fftw_destroy_plan(fftw_plan plan);
@@ -1585,7 +1585,7 @@
n)
performance even for prime sizes). It is possible to
- customize FFTW for different array sizes; see *Note
+ customize FFTW for different array sizes; see *note
Installation and Customization::. Transforms whose sizes are
powers of 2 are especially fast.
@@ -1604,13 +1604,13 @@
`FFTW_BACKWARD').
* `flags' is a bitwise OR (`|') of zero or more planner flags, as
- defined in *Note Planner Flags::.
+ defined in *note Planner Flags::.
FFTW computes an unnormalized transform: computing a forward
followed by a backward transform (or vice versa) will result in the
original data multiplied by the size of the transform (the product of
-the dimensions). For more information, see *Note What FFTW Really
+the dimensions). For more information, see *note What FFTW Really
Computes::.
@@ -1749,7 +1749,7 @@
* `n', or `nx'/`ny'/`nz', or `n[rank]', respectively, gives the size
of the _logical_ transform dimensions. They can be any positive
integer. This is different in general from the _physical_ array
- dimensions, which are described in *Note Real-data DFT Array
+ dimensions, which are described in *note Real-data DFT Array
Format::.
- FFTW is best at handling sizes of the form 2^a 3^b 5^c 7^d
@@ -1759,7 +1759,7 @@
n)
performance even for prime sizes). (It is possible to
- customize FFTW for different array sizes; see *Note
+ customize FFTW for different array sizes; see *note
Installation and Customization::.) Transforms whose sizes
are powers of 2 are especially fast, and it is generally
beneficial for the _last_ dimension of an r2c/c2r transform
@@ -1771,10 +1771,10 @@
used in the flags. (The arrays need not be initialized, but they
must be allocated.) For an in-place transform, it is important to
remember that the real array will require padding, described in
- *Note Real-data DFT Array Format::.
+ *note Real-data DFT Array Format::.
* `flags' is a bitwise OR (`|') of zero or more planner flags, as
- defined in *Note Planner Flags::.
+ defined in *note Planner Flags::.
The inverse transforms, taking complex input (storing the
@@ -1803,7 +1803,7 @@
dimensions). An r2c transform produces the same output as a
`FFTW_FORWARD' complex DFT of the same input, and a c2r transform is
correspondingly equivalent to `FFTW_BACKWARD'. For more information,
-see *Note What FFTW Really Computes::.
+see *note What FFTW Really Computes::.
File: fftw3.info, Node: Real-data DFT Array Format, Next: Real-to-Real
Transforms, Prev: Real-data DFTs, Up: Basic Interface
@@ -1905,7 +1905,7 @@
retains O(n log n)
performance even for prime sizes). (It is possible to
- customize FFTW for different array sizes; see *Note
+ customize FFTW for different array sizes; see *note
Installation and Customization::.) Transforms whose sizes
are powers of 2 are especially fast.
@@ -1921,13 +1921,13 @@
* `kind', or `kindx'/`kindy'/`kindz', or `kind[rank]', is the kind
of r2r transform used for the corresponding dimension. The valid
- kind constants are described in *Note Real-to-Real Transform
+ kind constants are described in *note Real-to-Real Transform
Kinds::. In a multi-dimensional transform, what is computed is
the separable product formed by taking each transform kind along
the corresponding dimension, one dimension after another.
* `flags' is a bitwise OR (`|') of zero or more planner flags, as
- defined in *Note Planner Flags::.
+ defined in *note Planner Flags::.
@@ -1938,8 +1938,8 @@
FFTW currently supports 11 different r2r transform kinds, specified by
one of the constants below. For the precise definitions of these
-transforms, see *Note What FFTW Really Computes::. For a more
-colloquial introduction to these transform kinds, see *Note More DFTs
+transforms, see *note What FFTW Really Computes::. For a more
+colloquial introduction to these transform kinds, see *note More DFTs
of Real Data::.
For dimension of size `n', there is a corresponding "logical"
@@ -2092,7 +2092,7 @@
are in units of `fftw_complex'.
If an `nembed' parameter is `NULL', it is interpreted as what it
-would be in the basic interface, as described in *Note Real-data DFT
+would be in the basic interface, as described in *note Real-data DFT
Array Format::. That is, for the complex array the size is assumed to
be the same as `n', but with the last dimension cut roughly in half.
For the real array, the size is assumed to be `n' if the transform is
@@ -2174,7 +2174,7 @@
which we call the interleaved and the split format.
The "interleaved" format is the same one used by the basic and
-advanced interfaces, and it is documented in *Note Complex numbers::.
+advanced interfaces, and it is documented in *note Complex numbers::.
In the interleaved format, you provide pointers to the real part of a
complex number, and the imaginary part understood to be stored in the
next memory location.
@@ -2269,7 +2269,7 @@
`howmany_rank', respectively.
`flags' is a bitwise OR (`|') of zero or more planner flags, as
-defined in *Note Planner Flags::.
+defined in *note Planner Flags::.
In the `fftw_plan_guru_dft' function, the pointers `in' and `out'
point to the interleaved input and output arrays, respectively. The
@@ -2292,7 +2292,7 @@
expressed in units of `double'. For a contiguous `fftw_complex' array,
the overall stride of the transform should be 2, the distance between
consecutive real parts or between consecutive imaginary parts; see
-*Note Guru vector and transform sizes::. Note that the dimension
+*note Guru vector and transform sizes::. Note that the dimension
strides are applied equally to the real and imaginary parts; real and
imaginary arrays with different strides are not supported.
@@ -2353,8 +2353,8 @@
as specified. It is up to the user to specify the strides
appropriately for the peculiar dimensions of the data, and we do not
guarantee that the planner will succeed (return non-`NULL') for any
-dimensions other than those described in *Note Real-data DFT Array
-Format:: and generalized in *Note Advanced Real-data DFTs::. (That is,
+dimensions other than those described in *note Real-data DFT Array
+Format:: and generalized in *note Advanced Real-data DFTs::. (That is,
for an in-place transform, each individual dimension should be able to
operate in place.)
@@ -2366,7 +2366,7 @@
transform.
`flags' is a bitwise OR (`|') of zero or more planner flags, as
-defined in *Note Planner Flags::.
+defined in *note Planner Flags::.
In-place transforms of rank greater than 1 are currently only
supported for interleaved arrays. For split arrays, the planner will
@@ -2393,14 +2393,14 @@
The transform kind of each dimension is given by the `kind'
parameter, which should point to an array of length `rank'. Valid
-`fftw_r2r_kind' constants are given in *Note Real-to-Real Transform
+`fftw_r2r_kind' constants are given in *note Real-to-Real Transform
Kinds::.
`in' and `out' point to the real input and output arrays; they may
be the same, indicating an in-place transform.
`flags' is a bitwise OR (`|') of zero or more planner flags, as
-defined in *Note Planner Flags::.
+defined in *note Planner Flags::.
File: fftw3.info, Node: Guru Execution of Plans, Prev: Guru Real-to-real
Transforms, Up: Guru Interface
@@ -2409,7 +2409,7 @@
-----------------------------
Normally, one executes a plan for the arrays with which the plan was
-created, by calling `fftw_execute(plan)' as described in *Note Using
+created, by calling `fftw_execute(plan)' as described in *note Using
Plans::. However, it is possible to apply a given plan to a _different_
array using the guru functions detailed below, provided that the
following conditions are met:
@@ -2715,7 +2715,7 @@
The proper definition of even symmetry for `REDFT10', `REDFT01', and
`REDFT11' transforms is somewhat more intricate because of the shifts
by 1/2 of the input and/or output, although the corresponding boundary
-conditions are given in *Note Real even/odd DFTs (cosine/sine
+conditions are given in *note Real even/odd DFTs (cosine/sine
transforms)::. Because of the even symmetry, however, the sine terms
in the DFT all cancel and the remaining cosine terms are written
explicitly below. This formulation often leads people to call such a
@@ -2791,7 +2791,7 @@
The proper definition of odd symmetry for `RODFT10', `RODFT01', and
`RODFT11' transforms is somewhat more intricate because of the shifts
by 1/2 of the input and/or output, although the corresponding boundary
-conditions are given in *Note Real even/odd DFTs (cosine/sine
+conditions are given in *note Real even/odd DFTs (cosine/sine
transforms)::. Because of the odd symmetry, however, the cosine terms
in the DFT all cancel and the remaining sine terms are written
explicitly below. This formulation often leads people to call such a
@@ -2882,7 +2882,7 @@
elements of the _last_ dimension (division by 2 is rounded down). (We
could instead have cut any other dimension in half, but the last
dimension proved computationally convenient.) This results in the
-peculiar array format described in more detail by *Note Real-data DFT
+peculiar array format described in more detail by *note Real-data DFT
Array Format::.
The multi-dimensional c2r transform is simply the unnormalized
@@ -2896,10 +2896,10 @@
as the usual multi-dimensional transform. A multi-dimensional `R2HC'
(or `HC2R') transform is not identical to the multi-dimensional DFT,
requiring some post-processing to combine the requisite real and
-imaginary parts, as was described in *Note The Halfcomplex-format
+imaginary parts, as was described in *note The Halfcomplex-format
DFT::. Likewise, FFTW's multidimensional `FFTW_DHT' r2r transform is
not the same thing as the logical multi-dimensional discrete Hartley
-transform defined in the literature, as discussed in *Note The Discrete
+transform defined in the literature, as discussed in *note The Discrete
Hartley Transform::.
@@ -2913,10 +2913,10 @@
Currently, FFTW 3 includes parallel transforms for shared-memory
machines with some flavor of threads (e.g. POSIX threads); any program
using FFTW can be trivially modified to use these transforms, which are
-documented in *Note Multi-threaded FFTW::.
+documented in *note Multi-threaded FFTW::.
Users calling FFTW from a multi-threaded program should also consult
-*Note Thread safety::. This section tells you which routines of FFTW it
+*note Thread safety::. This section tells you which routines of FFTW it
is safe to call in parallel from different shared-memory threads.
FFTW 2 also contains distributed-memory parallel transforms using the
@@ -3147,7 +3147,7 @@
for multi-dimensional real-complex transforms, discussed below.
* Wisdom import and export is somewhat more tricky because one cannot
- easily pass files or strings between C and Fortran; see *Note
+ easily pass files or strings between C and Fortran; see *note
Wisdom of Fortran?::.
* Fortran cannot use the `fftw_malloc' dynamic-allocation routine.
@@ -3303,7 +3303,7 @@
In this section, we discuss how one can import/export FFTW wisdom
(saved plans) to/from a Fortran program; we assume that the reader is
-already familiar with wisdom, as described in *Note Words of
+already familiar with wisdom, as described in *note Words of
Wisdom-Saving Plans::.
The basic problem is that is difficult to (portably) pass files and
@@ -4564,92 +4564,92 @@
Tag Table:
-Node: Top1074
-Node: Introduction3898
-Node: Tutorial10395
-Ref: Tutorial-Footnote-111639
-Node: Complex One-Dimensional DFTs11733
-Node: Complex Multi-Dimensional DFTs17353
-Node: One-Dimensional DFTs of Real Data19922
-Node: Multi-Dimensional DFTs of Real Data24163
-Node: More DFTs of Real Data27705
-Node: The Halfcomplex-format DFT31207
-Node: Real even/odd DFTs (cosine/sine transforms)33816
-Ref: Real even/odd DFTs (cosine/sine transforms)-Footnote-139426
-Ref: Real even/odd DFTs (cosine/sine transforms)-Footnote-239615
-Node: The Discrete Hartley Transform40550
-Ref: The Discrete Hartley Transform-Footnote-142894
-Node: Other Important Topics43143
-Node: Data Alignment43420
-Node: SIMD alignment and fftw_malloc43921
-Node: Stack alignment on x8645791
-Node: Multi-dimensional Array Format47435
-Node: Row-major Format48052
-Node: Column-major Format49709
-Node: Fixed-size Arrays in C50679
-Node: Dynamic Arrays in C52115
-Node: Dynamic Arrays in C-The Wrong Way53748
-Node: Words of Wisdom-Saving Plans55495
-Node: Caveats in Using Wisdom58102
-Node: FFTW Reference60190
-Node: Data Types and Files60635
-Node: Complex numbers61067
-Node: Precision62804
-Node: Memory Allocation63987
-Node: Using Plans64997
-Node: Basic Interface67860
-Node: Complex DFTs68359
-Node: Planner Flags72158
-Node: Real-data DFTs76418
-Node: Real-data DFT Array Format81320
-Node: Real-to-Real Transforms83533
-Node: Real-to-Real Transform Kinds87513
-Node: Advanced Interface89981
-Node: Advanced Complex DFTs90721
-Node: Advanced Real-data DFTs93468
-Node: Advanced Real-to-real Transforms95795
-Node: Guru Interface96901
-Node: Interleaved and split arrays98220
-Node: Guru vector and transform sizes99263
-Node: Guru Complex DFTs101826
-Node: Guru Real-data DFTs104662
-Node: Guru Real-to-real Transforms107479
-Node: Guru Execution of Plans108800
-Node: Wisdom112066
-Node: Wisdom Export112412
-Node: Wisdom Import114017
-Node: Forgetting Wisdom115795
-Node: Wisdom Utilities116167
-Node: What FFTW Really Computes117534
-Node: The 1d Discrete Fourier Transform (DFT)118359
-Node: The 1d Real-data DFT119718
-Node: 1d Real-even DFTs (DCTs)121372
-Node: 1d Real-odd DFTs (DSTs)124581
-Node: 1d Discrete Hartley Transforms (DHTs)127523
-Node: Multi-dimensional Transforms128199
-Node: Parallel FFTW130752
-Node: Multi-threaded FFTW131697
-Node: Installation and Supported Hardware/Software132569
-Node: Usage of Multi-threaded FFTW134075
-Node: How Many Threads to Use?136719
-Node: Thread safety137738
-Node: Calling FFTW from Fortran139445
-Node: Fortran-interface routines140224
-Ref: Fortran-interface routines-Footnote-1143103
-Ref: Fortran-interface routines-Footnote-2143306
-Node: FFTW Constants in Fortran143439
-Node: Fortran Examples144493
-Node: Wisdom of Fortran?147581
-Node: Upgrading from FFTW version 2149254
-Ref: Upgrading from FFTW version 2-Footnote-1158870
-Node: Installation and Customization159053
-Node: Installation on Unix160695
-Node: Installation on non-Unix systems167651
-Node: Cycle Counters170222
-Node: Generating your own code171972
-Node: Acknowledgments174080
-Node: License and Copyright177493
-Node: Concept Index179337
-Node: Library Index204480
+Node: Top1055
+Node: Introduction3879
+Node: Tutorial10376
+Ref: Tutorial-Footnote-111620
+Node: Complex One-Dimensional DFTs11714
+Node: Complex Multi-Dimensional DFTs17334
+Node: One-Dimensional DFTs of Real Data19903
+Node: Multi-Dimensional DFTs of Real Data24144
+Node: More DFTs of Real Data27686
+Node: The Halfcomplex-format DFT31188
+Node: Real even/odd DFTs (cosine/sine transforms)33797
+Ref: Real even/odd DFTs (cosine/sine transforms)-Footnote-139407
+Ref: Real even/odd DFTs (cosine/sine transforms)-Footnote-239596
+Node: The Discrete Hartley Transform40531
+Ref: The Discrete Hartley Transform-Footnote-142875
+Node: Other Important Topics43124
+Node: Data Alignment43401
+Node: SIMD alignment and fftw_malloc43902
+Node: Stack alignment on x8645772
+Node: Multi-dimensional Array Format47416
+Node: Row-major Format48033
+Node: Column-major Format49690
+Node: Fixed-size Arrays in C50660
+Node: Dynamic Arrays in C52096
+Node: Dynamic Arrays in C-The Wrong Way53729
+Node: Words of Wisdom-Saving Plans55476
+Node: Caveats in Using Wisdom58083
+Node: FFTW Reference60171
+Node: Data Types and Files60616
+Node: Complex numbers61048
+Node: Precision62785
+Node: Memory Allocation63968
+Node: Using Plans64978
+Node: Basic Interface67841
+Node: Complex DFTs68340
+Node: Planner Flags72139
+Node: Real-data DFTs76399
+Node: Real-data DFT Array Format81301
+Node: Real-to-Real Transforms83514
+Node: Real-to-Real Transform Kinds87494
+Node: Advanced Interface89962
+Node: Advanced Complex DFTs90702
+Node: Advanced Real-data DFTs93449
+Node: Advanced Real-to-real Transforms95776
+Node: Guru Interface96882
+Node: Interleaved and split arrays98201
+Node: Guru vector and transform sizes99244
+Node: Guru Complex DFTs101807
+Node: Guru Real-data DFTs104643
+Node: Guru Real-to-real Transforms107460
+Node: Guru Execution of Plans108781
+Node: Wisdom112047
+Node: Wisdom Export112393
+Node: Wisdom Import113998
+Node: Forgetting Wisdom115776
+Node: Wisdom Utilities116148
+Node: What FFTW Really Computes117515
+Node: The 1d Discrete Fourier Transform (DFT)118340
+Node: The 1d Real-data DFT119699
+Node: 1d Real-even DFTs (DCTs)121353
+Node: 1d Real-odd DFTs (DSTs)124562
+Node: 1d Discrete Hartley Transforms (DHTs)127504
+Node: Multi-dimensional Transforms128180
+Node: Parallel FFTW130733
+Node: Multi-threaded FFTW131678
+Node: Installation and Supported Hardware/Software132550
+Node: Usage of Multi-threaded FFTW134056
+Node: How Many Threads to Use?136700
+Node: Thread safety137719
+Node: Calling FFTW from Fortran139426
+Node: Fortran-interface routines140205
+Ref: Fortran-interface routines-Footnote-1143084
+Ref: Fortran-interface routines-Footnote-2143287
+Node: FFTW Constants in Fortran143420
+Node: Fortran Examples144474
+Node: Wisdom of Fortran?147562
+Node: Upgrading from FFTW version 2149235
+Ref: Upgrading from FFTW version 2-Footnote-1158851
+Node: Installation and Customization159034
+Node: Installation on Unix160676
+Node: Installation on non-Unix systems167632
+Node: Cycle Counters170203
+Node: Generating your own code171953
+Node: Acknowledgments174061
+Node: License and Copyright177474
+Node: Concept Index179318
+Node: Library Index204461
End Tag Table
signature.asc
Description: PGP signature
