slapin/ogre-base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updates

Browse Source
This commit is contained in:
Sergey Lapin
2025-07-12 12:17:44 +03:00
parent c759f60ff7
commit 792e1b937a
3507 changed files with 492613 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
fftw-3.3.10/doc/html/1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html Normal file
View File

@@ -0,0 +1,85 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>1d Discrete Hartley Transforms (DHTs) (FFTW 3.3.10)</title>
<meta name="description" content="1d Discrete Hartley Transforms (DHTs) (FFTW 3.3.10)">
<meta name="keywords" content="1d Discrete Hartley Transforms (DHTs) (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="What-FFTW-Really-Computes.html" rel="up" title="What FFTW Really Computes">
<link href="Multi_002ddimensional-Transforms.html" rel="next" title="Multi-dimensional Transforms">
<link href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html" rel="prev" title="1d Real-odd DFTs (DSTs)">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="g_t1d-Discrete-Hartley-Transforms-_0028DHTs_0029"></span><div class="header">
<p>
Next: <a href="Multi_002ddimensional-Transforms.html" accesskey="n" rel="next">Multi-dimensional Transforms</a>, Previous: <a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html" accesskey="p" rel="prev">1d Real-odd DFTs (DSTs)</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="g_t1d-Discrete-Hartley-Transforms-_0028DHTs_0029-1"></span><h4 class="subsection">4.8.5 1d Discrete Hartley Transforms (DHTs)</h4>
<span id="index-discrete-Hartley-transform-2"></span>
<span id="index-DHT-1"></span>
<p>The discrete Hartley transform (DHT) of a 1d real array <em>X</em> of size
<em>n</em> computes a real array <em>Y</em> of the same size, where:
<center><img src="equation-dht.png" align="top">.</center>
</p>
<span id="index-normalization-12"></span>
<p>FFTW computes an unnormalized transform, in that there is no coefficient
in front of the summation in the DHT. In other words, applying the
transform twice (the DHT is its own inverse) will multiply the input by
<em>n</em>.
</p>
</body>
</html>

155
fftw-3.3.10/doc/html/1d-Real_002deven-DFTs-_0028DCTs_0029.html Normal file
View File

@@ -0,0 +1,155 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>1d Real-even DFTs (DCTs) (FFTW 3.3.10)</title>
<meta name="description" content="1d Real-even DFTs (DCTs) (FFTW 3.3.10)">
<meta name="keywords" content="1d Real-even DFTs (DCTs) (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="What-FFTW-Really-Computes.html" rel="up" title="What FFTW Really Computes">
<link href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html" rel="next" title="1d Real-odd DFTs (DSTs)">
<link href="The-1d-Real_002ddata-DFT.html" rel="prev" title="The 1d Real-data DFT">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="g_t1d-Real_002deven-DFTs-_0028DCTs_0029"></span><div class="header">
<p>
Next: <a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html" accesskey="n" rel="next">1d Real-odd DFTs (DSTs)</a>, Previous: <a href="The-1d-Real_002ddata-DFT.html" accesskey="p" rel="prev">The 1d Real-data DFT</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="g_t1d-Real_002deven-DFTs-_0028DCTs_0029-1"></span><h4 class="subsection">4.8.3 1d Real-even DFTs (DCTs)</h4>
<p>The Real-even symmetry DFTs in FFTW are exactly equivalent to the unnormalized
forward (and backward) DFTs as defined above, where the input array
<em>X</em> of length <em>N</em> is purely real and is also <em>even</em> symmetry. In
this case, the output array is likewise real and even symmetry.
<span id="index-real_002deven-DFT-1"></span>
<span id="index-REDFT-1"></span>
</p>
<span id="index-REDFT00"></span>
<p>For the case of <code>REDFT00</code>, this even symmetry means that
<i>X<sub>j</sub> = X<sub>N-j</sub></i>,
where we take <em>X</em> to be periodic so that
<i>X<sub>N</sub> = X</i><sub>0</sub>.
Because of this redundancy, only the first <em>n</em> real numbers are
actually stored, where <em>N = 2(n-1)</em>.
</p>
<p>The proper definition of even symmetry for <code>REDFT10</code>,
<code>REDFT01</code>, and <code>REDFT11</code> transforms is somewhat more intricate
because of the shifts by <em>1/2</em> of the input and/or output, although
the corresponding boundary conditions are given in <a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a>. 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 transform a <em>discrete cosine transform</em> (DCT), although it is
really just a special case of the DFT.
<span id="index-discrete-cosine-transform-2"></span>
<span id="index-DCT-2"></span>
</p>
<p>In each of the definitions below, we transform a real array <em>X</em> of
length <em>n</em> to a real array <em>Y</em> of length <em>n</em>:
</p>
<span id="REDFT00-_0028DCT_002dI_0029"></span><h4 class="subsubheading">REDFT00 (DCT-I)</h4>
<span id="index-REDFT00-1"></span>
<p>An <code>REDFT00</code> transform (type-I DCT) in FFTW is defined by:
<center><img src="equation-redft00.png" align="top">.</center>
Note that this transform is not defined for <em>n=1</em>. For <em>n=2</em>,
the summation term above is dropped as you might expect.
</p>
<span id="REDFT10-_0028DCT_002dII_0029"></span><h4 class="subsubheading">REDFT10 (DCT-II)</h4>
<span id="index-REDFT10"></span>
<p>An <code>REDFT10</code> transform (type-II DCT, sometimes called &ldquo;the&rdquo; DCT) in FFTW is defined by:
<center><img src="equation-redft10.png" align="top">.</center>
</p>
<span id="REDFT01-_0028DCT_002dIII_0029"></span><h4 class="subsubheading">REDFT01 (DCT-III)</h4>
<span id="index-REDFT01"></span>
<p>An <code>REDFT01</code> transform (type-III DCT) in FFTW is defined by:
<center><img src="equation-redft01.png" align="top">.</center>
In the case of <em>n=1</em>, this reduces to
<i>Y</i><sub>0</sub> = <i>X</i><sub>0</sub>.
Up to a scale factor (see below), this is the inverse of <code>REDFT10</code> (&ldquo;the&rdquo; DCT), and so the <code>REDFT01</code> (DCT-III) is sometimes called the &ldquo;IDCT&rdquo;.
<span id="index-IDCT-3"></span>
</p>
<span id="REDFT11-_0028DCT_002dIV_0029"></span><h4 class="subsubheading">REDFT11 (DCT-IV)</h4>
<span id="index-REDFT11"></span>
<p>An <code>REDFT11</code> transform (type-IV DCT) in FFTW is defined by:
<center><img src="equation-redft11.png" align="top">.</center>
</p>
<span id="Inverses-and-Normalization"></span><h4 class="subsubheading">Inverses and Normalization</h4>
<p>These definitions correspond directly to the unnormalized DFTs used
elsewhere in FFTW (hence the factors of <em>2</em> in front of the
summations). The unnormalized inverse of <code>REDFT00</code> is
<code>REDFT00</code>, of <code>REDFT10</code> is <code>REDFT01</code> and vice versa, and
of <code>REDFT11</code> is <code>REDFT11</code>. Each unnormalized inverse results
in the original array multiplied by <em>N</em>, where <em>N</em> is the
<em>logical</em> DFT size. For <code>REDFT00</code>, <em>N=2(n-1)</em> (note that
<em>n=1</em> is not defined); otherwise, <em>N=2n</em>.
<span id="index-normalization-10"></span>
</p>
<p>In defining the discrete cosine transform, some authors also include
additional factors of
&radic;2
(or its inverse) multiplying selected inputs and/or outputs. This is a
mostly cosmetic change that makes the transform orthogonal, but
sacrifices the direct equivalence to a symmetric DFT.
</p>
<hr>
<div class="header">
<p>
Next: <a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html" accesskey="n" rel="next">1d Real-odd DFTs (DSTs)</a>, Previous: <a href="The-1d-Real_002ddata-DFT.html" accesskey="p" rel="prev">The 1d Real-data DFT</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

152
fftw-3.3.10/doc/html/1d-Real_002dodd-DFTs-_0028DSTs_0029.html Normal file
View File

@@ -0,0 +1,152 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>1d Real-odd DFTs (DSTs) (FFTW 3.3.10)</title>
<meta name="description" content="1d Real-odd DFTs (DSTs) (FFTW 3.3.10)">
<meta name="keywords" content="1d Real-odd DFTs (DSTs) (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="What-FFTW-Really-Computes.html" rel="up" title="What FFTW Really Computes">
<link href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html" rel="next" title="1d Discrete Hartley Transforms (DHTs)">
<link href="1d-Real_002deven-DFTs-_0028DCTs_0029.html" rel="prev" title="1d Real-even DFTs (DCTs)">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="g_t1d-Real_002dodd-DFTs-_0028DSTs_0029"></span><div class="header">
<p>
Next: <a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html" accesskey="n" rel="next">1d Discrete Hartley Transforms (DHTs)</a>, Previous: <a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html" accesskey="p" rel="prev">1d Real-even DFTs (DCTs)</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="g_t1d-Real_002dodd-DFTs-_0028DSTs_0029-1"></span><h4 class="subsection">4.8.4 1d Real-odd DFTs (DSTs)</h4>
<p>The Real-odd symmetry DFTs in FFTW are exactly equivalent to the unnormalized
forward (and backward) DFTs as defined above, where the input array
<em>X</em> of length <em>N</em> is purely real and is also <em>odd</em> symmetry. In
this case, the output is odd symmetry and purely imaginary.
<span id="index-real_002dodd-DFT-1"></span>
<span id="index-RODFT-1"></span>
</p>
<span id="index-RODFT00"></span>
<p>For the case of <code>RODFT00</code>, this odd symmetry means that
<i>X<sub>j</sub> = -X<sub>N-j</sub></i>,
where we take <em>X</em> to be periodic so that
<i>X<sub>N</sub> = X</i><sub>0</sub>.
Because of this redundancy, only the first <em>n</em> real numbers
starting at <em>j=1</em> are actually stored (the <em>j=0</em> element is
zero), where <em>N = 2(n+1)</em>.
</p>
<p>The proper definition of odd symmetry for <code>RODFT10</code>,
<code>RODFT01</code>, and <code>RODFT11</code> transforms is somewhat more intricate
because of the shifts by <em>1/2</em> of the input and/or output, although
the corresponding boundary conditions are given in <a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a>. 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 transform a <em>discrete sine transform</em> (DST), although it is
really just a special case of the DFT.
<span id="index-discrete-sine-transform-2"></span>
<span id="index-DST-2"></span>
</p>
<p>In each of the definitions below, we transform a real array <em>X</em> of
length <em>n</em> to a real array <em>Y</em> of length <em>n</em>:
</p>
<span id="RODFT00-_0028DST_002dI_0029"></span><h4 class="subsubheading">RODFT00 (DST-I)</h4>
<span id="index-RODFT00-1"></span>
<p>An <code>RODFT00</code> transform (type-I DST) in FFTW is defined by:
<center><img src="equation-rodft00.png" align="top">.</center>
</p>
<span id="RODFT10-_0028DST_002dII_0029"></span><h4 class="subsubheading">RODFT10 (DST-II)</h4>
<span id="index-RODFT10"></span>
<p>An <code>RODFT10</code> transform (type-II DST) in FFTW is defined by:
<center><img src="equation-rodft10.png" align="top">.</center>
</p>
<span id="RODFT01-_0028DST_002dIII_0029"></span><h4 class="subsubheading">RODFT01 (DST-III)</h4>
<span id="index-RODFT01"></span>
<p>An <code>RODFT01</code> transform (type-III DST) in FFTW is defined by:
<center><img src="equation-rodft01.png" align="top">.</center>
In the case of <em>n=1</em>, this reduces to
<i>Y</i><sub>0</sub> = <i>X</i><sub>0</sub>.
</p>
<span id="RODFT11-_0028DST_002dIV_0029"></span><h4 class="subsubheading">RODFT11 (DST-IV)</h4>
<span id="index-RODFT11"></span>
<p>An <code>RODFT11</code> transform (type-IV DST) in FFTW is defined by:
<center><img src="equation-rodft11.png" align="top">.</center>
</p>
<span id="Inverses-and-Normalization-1"></span><h4 class="subsubheading">Inverses and Normalization</h4>
<p>These definitions correspond directly to the unnormalized DFTs used
elsewhere in FFTW (hence the factors of <em>2</em> in front of the
summations). The unnormalized inverse of <code>RODFT00</code> is
<code>RODFT00</code>, of <code>RODFT10</code> is <code>RODFT01</code> and vice versa, and
of <code>RODFT11</code> is <code>RODFT11</code>. Each unnormalized inverse results
in the original array multiplied by <em>N</em>, where <em>N</em> is the
<em>logical</em> DFT size. For <code>RODFT00</code>, <em>N=2(n+1)</em>;
otherwise, <em>N=2n</em>.
<span id="index-normalization-11"></span>
</p>
<p>In defining the discrete sine transform, some authors also include
additional factors of
&radic;2
(or its inverse) multiplying selected inputs and/or outputs. This is a
mostly cosmetic change that makes the transform orthogonal, but
sacrifices the direct equivalence to an antisymmetric DFT.
</p>
<hr>
<div class="header">
<p>
Next: <a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html" accesskey="n" rel="next">1d Discrete Hartley Transforms (DHTs)</a>, Previous: <a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html" accesskey="p" rel="prev">1d Real-even DFTs (DCTs)</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

183
fftw-3.3.10/doc/html/2d-MPI-example.html Normal file
View File

@@ -0,0 +1,183 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>2d MPI example (FFTW 3.3.10)</title>
<meta name="description" content="2d MPI example (FFTW 3.3.10)">
<meta name="keywords" content="2d MPI example (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="MPI-Data-Distribution.html" rel="next" title="MPI Data Distribution">
<link href="Linking-and-Initializing-MPI-FFTW.html" rel="prev" title="Linking and Initializing MPI FFTW">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="g_t2d-MPI-example"></span><div class="header">
<p>
Next: <a href="MPI-Data-Distribution.html" accesskey="n" rel="next">MPI Data Distribution</a>, Previous: <a href="Linking-and-Initializing-MPI-FFTW.html" accesskey="p" rel="prev">Linking and Initializing MPI FFTW</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="g_t2d-MPI-example-1"></span><h3 class="section">6.3 2d MPI example</h3>
<p>Before we document the FFTW MPI interface in detail, we begin with a
simple example outlining how one would perform a two-dimensional
<code>N0</code> by <code>N1</code> complex DFT.
</p>
<div class="example">
<pre class="example">#include &lt;fftw3-mpi.h&gt;
int main(int argc, char **argv)
{
const ptrdiff_t N0 = ..., N1 = ...;
fftw_plan plan;
fftw_complex *data;
ptrdiff_t alloc_local, local_n0, local_0_start, i, j;
MPI_Init(&amp;argc, &amp;argv);
fftw_mpi_init();
/* <span class="roman">get local data size and allocate</span> */
alloc_local = fftw_mpi_local_size_2d(N0, N1, MPI_COMM_WORLD,
&amp;local_n0, &amp;local_0_start);
data = fftw_alloc_complex(alloc_local);
/* <span class="roman">create plan for in-place forward DFT</span> */
plan = fftw_mpi_plan_dft_2d(N0, N1, data, data, MPI_COMM_WORLD,
FFTW_FORWARD, FFTW_ESTIMATE);
/* <span class="roman">initialize data to some function</span> my_function(x,y) */
for (i = 0; i &lt; local_n0; ++i) for (j = 0; j &lt; N1; ++j)
data[i*N1 + j] = my_function(local_0_start + i, j);
/* <span class="roman">compute transforms, in-place, as many times as desired</span> */
fftw_execute(plan);
fftw_destroy_plan(plan);
MPI_Finalize();
}
</pre></div>
<p>As can be seen above, the MPI interface follows the same basic style
of allocate/plan/execute/destroy as the serial FFTW routines. All of
the MPI-specific routines are prefixed with &lsquo;<samp>fftw_mpi_</samp>&rsquo; instead
of &lsquo;<samp>fftw_</samp>&rsquo;. There are a few important differences, however:
</p>
<p>First, we must call <code>fftw_mpi_init()</code> after calling
<code>MPI_Init</code> (required in all MPI programs) and before calling any
other &lsquo;<samp>fftw_mpi_</samp>&rsquo; routine.
<span id="index-MPI_005fInit"></span>
<span id="index-fftw_005fmpi_005finit-1"></span>
</p>
<p>Second, when we create the plan with <code>fftw_mpi_plan_dft_2d</code>,
analogous to <code>fftw_plan_dft_2d</code>, we pass an additional argument:
the communicator, indicating which processes will participate in the
transform (here <code>MPI_COMM_WORLD</code>, indicating all processes).
Whenever you create, execute, or destroy a plan for an MPI transform,
you must call the corresponding FFTW routine on <em>all</em> processes
in the communicator for that transform. (That is, these are
<em>collective</em> calls.) Note that the plan for the MPI transform
uses the standard <code>fftw_execute</code> and <code>fftw_destroy</code> routines
(on the other hand, there are MPI-specific new-array execute functions
documented below).
<span id="index-collective-function"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005f2d"></span>
<span id="index-MPI_005fCOMM_005fWORLD-1"></span>
</p>
<p>Third, all of the FFTW MPI routines take <code>ptrdiff_t</code> arguments
instead of <code>int</code> as for the serial FFTW. <code>ptrdiff_t</code> is a
standard C integer type which is (at least) 32 bits wide on a 32-bit
machine and 64 bits wide on a 64-bit machine. This is to make it easy
to specify very large parallel transforms on a 64-bit machine. (You
can specify 64-bit transform sizes in the serial FFTW, too, but only
by using the &lsquo;<samp>guru64</samp>&rsquo; planner interface. See <a href="64_002dbit-Guru-Interface.html">64-bit Guru Interface</a>.)
<span id="index-ptrdiff_005ft-1"></span>
<span id="index-64_002dbit-architecture-1"></span>
</p>
<p>Fourth, and most importantly, you don&rsquo;t allocate the entire
two-dimensional array on each process. Instead, you call
<code>fftw_mpi_local_size_2d</code> to find out what <em>portion</em> of the
array resides on each processor, and how much space to allocate.
Here, the portion of the array on each process is a <code>local_n0</code> by
<code>N1</code> slice of the total array, starting at index
<code>local_0_start</code>. The total number of <code>fftw_complex</code> numbers
to allocate is given by the <code>alloc_local</code> return value, which
<em>may</em> be greater than <code>local_n0 * N1</code> (in case some
intermediate calculations require additional storage). The data
distribution in FFTW&rsquo;s MPI interface is described in more detail by
the next section.
<span id="index-fftw_005fmpi_005flocal_005fsize_005f2d"></span>
<span id="index-data-distribution-1"></span>
</p>
<p>Given the portion of the array that resides on the local process, it
is straightforward to initialize the data (here to a function
<code>myfunction</code>) and otherwise manipulate it. Of course, at the end
of the program you may want to output the data somehow, but
synchronizing this output is up to you and is beyond the scope of this
manual. (One good way to output a large multi-dimensional distributed
array in MPI to a portable binary file is to use the free HDF5
library; see the <a href="http://www.hdfgroup.org/">HDF home page</a>.)
<span id="index-HDF5"></span>
<span id="index-MPI-I_002fO"></span>
</p>
<hr>
<div class="header">
<p>
Next: <a href="MPI-Data-Distribution.html" accesskey="n" rel="next">MPI Data Distribution</a>, Previous: <a href="Linking-and-Initializing-MPI-FFTW.html" accesskey="p" rel="prev">Linking and Initializing MPI FFTW</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

137
fftw-3.3.10/doc/html/64_002dbit-Guru-Interface.html Normal file
View File

@@ -0,0 +1,137 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>64-bit Guru Interface (FFTW 3.3.10)</title>
<meta name="description" content="64-bit Guru Interface (FFTW 3.3.10)">
<meta name="keywords" content="64-bit Guru Interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Guru-Interface.html" rel="up" title="Guru Interface">
<link href="New_002darray-Execute-Functions.html" rel="next" title="New-array Execute Functions">
<link href="Guru-Real_002dto_002dreal-Transforms.html" rel="prev" title="Guru Real-to-real Transforms">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="g_t64_002dbit-Guru-Interface"></span><div class="header">
<p>
Previous: <a href="Guru-Real_002dto_002dreal-Transforms.html" accesskey="p" rel="prev">Guru Real-to-real Transforms</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="g_t64_002dbit-Guru-Interface-1"></span><h4 class="subsection">4.5.6 64-bit Guru Interface</h4>
<span id="index-64_002dbit-architecture"></span>
<p>When compiled in 64-bit mode on a 64-bit architecture (where addresses
are 64 bits wide), FFTW uses 64-bit quantities internally for all
transform sizes, strides, and so on&mdash;you don&rsquo;t have to do anything
special to exploit this. However, in the ordinary FFTW interfaces,
you specify the transform size by an <code>int</code> quantity, which is
normally only 32 bits wide. This means that, even though FFTW is
using 64-bit sizes internally, you cannot specify a single transform
dimension larger than
2<sup><small>31</small></sup>&minus;1
numbers.
</p>
<p>We expect that few users will require transforms larger than this, but,
for those who do, we provide a 64-bit version of the guru interface in
which all sizes are specified as integers of type <code>ptrdiff_t</code>
instead of <code>int</code>. (<code>ptrdiff_t</code> is a signed integer type
defined by the C standard to be wide enough to represent address
differences, and thus must be at least 64 bits wide on a 64-bit
machine.) We stress that there is <em>no performance advantage</em> to
using this interface&mdash;the same internal FFTW code is employed
regardless&mdash;and it is only necessary if you want to specify very
large transform sizes.
<span id="index-ptrdiff_005ft"></span>
</p>
<p>In particular, the 64-bit guru interface is a set of planner routines
that are exactly the same as the guru planner routines, except that
they are named with &lsquo;<samp>guru64</samp>&rsquo; instead of &lsquo;<samp>guru</samp>&rsquo; and they take
arguments of type <code>fftw_iodim64</code> instead of <code>fftw_iodim</code>.
For example, instead of <code>fftw_plan_guru_dft</code>, we have
<code>fftw_plan_guru64_dft</code>.
</p>
<div class="example">
<pre class="example">fftw_plan fftw_plan_guru64_dft(
int rank, const fftw_iodim64 *dims,
int howmany_rank, const fftw_iodim64 *howmany_dims,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fguru64_005fdft"></span>
<p>The <code>fftw_iodim64</code> type is similar to <code>fftw_iodim</code>, with the
same interpretation, except that it uses type <code>ptrdiff_t</code> instead
of type <code>int</code>.
</p>
<div class="example">
<pre class="example">typedef struct {
ptrdiff_t n;
ptrdiff_t is;
ptrdiff_t os;
} fftw_iodim64;
</pre></div>
<span id="index-fftw_005fiodim64"></span>
<p>Every other &lsquo;<samp>fftw_plan_guru</samp>&rsquo; function also has a
&lsquo;<samp>fftw_plan_guru64</samp>&rsquo; equivalent, but we do not repeat their
documentation here since they are identical to the 32-bit versions
except as noted above.
</p>
<hr>
<div class="header">
<p>
Previous: <a href="Guru-Real_002dto_002dreal-Transforms.html" accesskey="p" rel="prev">Guru Real-to-real Transforms</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

91
fftw-3.3.10/doc/html/Accessing-the-wisdom-API-from-Fortran.html Normal file
View File

@@ -0,0 +1,91 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Accessing the wisdom API from Fortran (FFTW 3.3.10)</title>
<meta name="description" content="Accessing the wisdom API from Fortran (FFTW 3.3.10)">
<meta name="keywords" content="Accessing the wisdom API from Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="up" title="Calling FFTW from Modern Fortran">
<link href="Wisdom-File-Export_002fImport-from-Fortran.html" rel="next" title="Wisdom File Export/Import from Fortran">
<link href="Allocating-aligned-memory-in-Fortran.html" rel="prev" title="Allocating aligned memory in Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Accessing-the-wisdom-API-from-Fortran"></span><div class="header">
<p>
Next: <a href="Defining-an-FFTW-module.html" accesskey="n" rel="next">Defining an FFTW module</a>, Previous: <a href="Allocating-aligned-memory-in-Fortran.html" accesskey="p" rel="prev">Allocating aligned memory in Fortran</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Accessing-the-wisdom-API-from-Fortran-1"></span><h3 class="section">7.6 Accessing the wisdom API from Fortran</h3>
<span id="index-wisdom-3"></span>
<span id="index-saving-plans-to-disk-3"></span>
<p>As explained in <a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a>, FFTW provides a
&ldquo;wisdom&rdquo; API for saving plans to disk so that they can be recreated
quickly. The C API for exporting (see <a href="Wisdom-Export.html">Wisdom Export</a>) and
importing (see <a href="Wisdom-Import.html">Wisdom Import</a>) wisdom is somewhat tricky to use
from Fortran, however, because of differences in file I/O and string
types between C and Fortran.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Wisdom-File-Export_002fImport-from-Fortran.html" accesskey="1">Wisdom File Export/Import from Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Wisdom-String-Export_002fImport-from-Fortran.html" accesskey="2">Wisdom String Export/Import from Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Wisdom-Generic-Export_002fImport-from-Fortran.html" accesskey="3">Wisdom Generic Export/Import from Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

164
fftw-3.3.10/doc/html/Acknowledgments.html Normal file
View File

@@ -0,0 +1,164 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Acknowledgments (FFTW 3.3.10)</title>
<meta name="description" content="Acknowledgments (FFTW 3.3.10)">
<meta name="keywords" content="Acknowledgments (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="License-and-Copyright.html" rel="next" title="License and Copyright">
<link href="Generating-your-own-code.html" rel="prev" title="Generating your own code">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Acknowledgments"></span><div class="header">
<p>
Next: <a href="License-and-Copyright.html" accesskey="n" rel="next">License and Copyright</a>, Previous: <a href="Installation-and-Customization.html" accesskey="p" rel="prev">Installation and Customization</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Acknowledgments-1"></span><h2 class="chapter">11 Acknowledgments</h2>
<p>Matteo Frigo was supported in part by the Special Research Program SFB
F011 &ldquo;AURORA&rdquo; of the Austrian Science Fund FWF and by MIT Lincoln
Laboratory. For previous versions of FFTW, he was supported in part by the
Defense Advanced Research Projects Agency (DARPA), under Grants
N00014-94-1-0985 and F30602-97-1-0270, and by a Digital Equipment
Corporation Fellowship.
</p>
<p>Steven G. Johnson was supported in part by a Dept.&nbsp;of Defense NDSEG
Fellowship, an MIT Karl Taylor Compton Fellowship, and by the Materials
Research Science and Engineering Center program of the National Science
Foundation under award DMR-9400334.
</p>
<p>Code for the Cell Broadband Engine was graciously donated to the FFTW
project by the IBM Austin Research Lab and included in fftw-3.2. (This
code was removed in fftw-3.3.)
</p>
<p>Code for the MIPS paired-single SIMD support was graciously donated to
the FFTW project by CodeSourcery, Inc.
</p>
<p>We are grateful to Sun Microsystems Inc.&nbsp;for its donation of a
cluster of 9 8-processor Ultra HPC 5000 SMPs (24 Gflops peak). These
machines served as the primary platform for the development of early
versions of FFTW.
</p>
<p>We thank Intel Corporation for donating a four-processor Pentium Pro
machine. We thank the GNU/Linux community for giving us a decent OS to
run on that machine.
</p>
<p>We are thankful to the AMD corporation for donating an AMD Athlon XP 1700+
computer to the FFTW project.
</p>
<p>We thank the Compaq/HP testdrive program and VA Software Corporation
(SourceForge.net) for providing remote access to machines that were used
to test FFTW.
</p>
<p>The <code>genfft</code> suite of code generators was written using Objective
Caml, a dialect of ML. Objective Caml is a small and elegant language
developed by Xavier Leroy. The implementation is available from
<a href="http://caml.inria.fr/"><code>http://caml.inria.fr/</code></a>. In previous
releases of FFTW, <code>genfft</code> was written in Caml Light, by the same
authors. An even earlier implementation of <code>genfft</code> was written in
Scheme, but Caml is definitely better for this kind of application.
<span id="index-Caml-1"></span>
<span id="index-LISP"></span>
</p>
<p>FFTW uses many tools from the GNU project, including <code>automake</code>,
<code>texinfo</code>, and <code>libtool</code>.
</p>
<p>Prof.&nbsp;Charles E.&nbsp;Leiserson of MIT provided continuous support and
encouragement. This program would not exist without him. Charles also
proposed the name &ldquo;codelets&rdquo; for the basic FFT blocks.
<span id="index-codelet-3"></span>
</p>
<p>Prof.&nbsp;John D.&nbsp;Joannopoulos of MIT demonstrated continuing tolerance of
Steven&rsquo;s &ldquo;extra-curricular&rdquo; computer-science activities, as well as
remarkable creativity in working them into his grant proposals.
Steven&rsquo;s physics degree would not exist without him.
</p>
<p>Franz Franchetti wrote SIMD extensions to FFTW 2, which eventually
led to the SIMD support in FFTW 3.
</p>
<p>Stefan Kral wrote most of the K7 code generator distributed with FFTW
3.0.x and 3.1.x.
</p>
<p>Andrew Sterian contributed the Windows timing code in FFTW 2.
</p>
<p>Didier Miras reported a bug in the test procedure used in FFTW 1.2. We
now use a completely different test algorithm by Funda Ergun that does
not require a separate FFT program to compare against.
</p>
<p>Wolfgang Reimer contributed the Pentium cycle counter and a few fixes
that help portability.
</p>
<p>Ming-Chang Liu uncovered a well-hidden bug in the complex transforms of
FFTW 2.0 and supplied a patch to correct it.
</p>
<p>The FFTW FAQ was written in <code>bfnn</code> (Bizarre Format With No Name)
and formatted using the tools developed by Ian Jackson for the Linux
FAQ.
</p>
<p><em>We are especially thankful to all of our users for their
continuing support, feedback, and interest during our development of
FFTW.</em>
</p>
<hr>
<div class="header">
<p>
Next: <a href="License-and-Copyright.html" accesskey="n" rel="next">License and Copyright</a>, Previous: <a href="Installation-and-Customization.html" accesskey="p" rel="prev">Installation and Customization</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

177
fftw-3.3.10/doc/html/Advanced-Complex-DFTs.html Normal file
View File

@@ -0,0 +1,177 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Advanced Complex DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Advanced Complex DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Advanced Complex DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Advanced-Interface.html" rel="up" title="Advanced Interface">
<link href="Advanced-Real_002ddata-DFTs.html" rel="next" title="Advanced Real-data DFTs">
<link href="Advanced-Interface.html" rel="prev" title="Advanced Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Advanced-Complex-DFTs"></span><div class="header">
<p>
Next: <a href="Advanced-Real_002ddata-DFTs.html" accesskey="n" rel="next">Advanced Real-data DFTs</a>, Previous: <a href="Advanced-Interface.html" accesskey="p" rel="prev">Advanced Interface</a>, Up: <a href="Advanced-Interface.html" accesskey="u" rel="up">Advanced Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Advanced-Complex-DFTs-1"></span><h4 class="subsection">4.4.1 Advanced Complex DFTs</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_many_dft(int rank, const int *n, int howmany,
fftw_complex *in, const int *inembed,
int istride, int idist,
fftw_complex *out, const int *onembed,
int ostride, int odist,
int sign, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fmany_005fdft"></span>
<p>This routine plans multiple multidimensional complex DFTs, and it
extends the <code>fftw_plan_dft</code> routine (see <a href="Complex-DFTs.html">Complex DFTs</a>) to
compute <code>howmany</code> transforms, each having rank <code>rank</code> and size
<code>n</code>. In addition, the transform data need not be contiguous, but
it may be laid out in memory with an arbitrary stride. To account for
these possibilities, <code>fftw_plan_many_dft</code> adds the new parameters
<code>howmany</code>, {<code>i</code>,<code>o</code>}<code>nembed</code>,
{<code>i</code>,<code>o</code>}<code>stride</code>, and
{<code>i</code>,<code>o</code>}<code>dist</code>. The FFTW basic interface
(see <a href="Complex-DFTs.html">Complex DFTs</a>) provides routines specialized for ranks 1, 2,
and&nbsp;3, but the advanced interface handles only the general-rank
case.
</p>
<p><code>howmany</code> is the (nonnegative) number of transforms to compute. The resulting
plan computes <code>howmany</code> transforms, where the input of the
<code>k</code>-th transform is at location <code>in+k*idist</code> (in C pointer
arithmetic), and its output is at location <code>out+k*odist</code>. Plans
obtained in this way can often be faster than calling FFTW multiple
times for the individual transforms. The basic <code>fftw_plan_dft</code>
interface corresponds to <code>howmany=1</code> (in which case the <code>dist</code>
parameters are ignored).
<span id="index-howmany-parameter"></span>
<span id="index-dist"></span>
</p>
<p>Each of the <code>howmany</code> transforms has rank <code>rank</code> and size
<code>n</code>, as in the basic interface. In addition, the advanced
interface allows the input and output arrays of each transform to be
row-major subarrays of larger rank-<code>rank</code> arrays, described by
<code>inembed</code> and <code>onembed</code> parameters, respectively.
{<code>i</code>,<code>o</code>}<code>nembed</code> must be arrays of length <code>rank</code>,
and <code>n</code> should be elementwise less than or equal to
{<code>i</code>,<code>o</code>}<code>nembed</code>. Passing <code>NULL</code> for an
<code>nembed</code> parameter is equivalent to passing <code>n</code> (i.e. same
physical and logical dimensions, as in the basic interface.)
</p>
<p>The <code>stride</code> parameters indicate that the <code>j</code>-th element of
the input or output arrays is located at <code>j*istride</code> or
<code>j*ostride</code>, respectively. (For a multi-dimensional array,
<code>j</code> is the ordinary row-major index.) When combined with the
<code>k</code>-th transform in a <code>howmany</code> loop, from above, this means
that the (<code>j</code>,<code>k</code>)-th element is at <code>j*stride+k*dist</code>.
(The basic <code>fftw_plan_dft</code> interface corresponds to a stride of 1.)
<span id="index-stride-1"></span>
</p>
<p>For in-place transforms, the input and output <code>stride</code> and
<code>dist</code> parameters should be the same; otherwise, the planner may
return <code>NULL</code>.
</p>
<p>Arrays <code>n</code>, <code>inembed</code>, and <code>onembed</code> are not used after
this function returns. You can safely free or reuse them.
</p>
<p><strong>Examples</strong>:
One transform of one 5 by 6 array contiguous in memory:
</p><div class="example">
<pre class="example"> int rank = 2;
int n[] = {5, 6};
int howmany = 1;
int idist = odist = 0; /* unused because howmany = 1 */
int istride = ostride = 1; /* array is contiguous in memory */
int *inembed = n, *onembed = n;
</pre></div>
<p>Transform of three 5 by 6 arrays, each contiguous in memory,
stored in memory one after another:
</p><div class="example">
<pre class="example"> int rank = 2;
int n[] = {5, 6};
int howmany = 3;
int idist = odist = n[0]*n[1]; /* = 30, the distance in memory
between the first element
of the first array and the
first element of the second array */
int istride = ostride = 1; /* array is contiguous in memory */
int *inembed = n, *onembed = n;
</pre></div>
<p>Transform each column of a 2d array with 10 rows and 3 columns:
</p><div class="example">
<pre class="example"> int rank = 1; /* not 2: we are computing 1d transforms */
int n[] = {10}; /* 1d transforms of length 10 */
int howmany = 3;
int idist = odist = 1;
int istride = ostride = 3; /* distance between two elements in
the same column */
int *inembed = n, *onembed = n;
</pre></div>
<hr>
<div class="header">
<p>
Next: <a href="Advanced-Real_002ddata-DFTs.html" accesskey="n" rel="next">Advanced Real-data DFTs</a>, Previous: <a href="Advanced-Interface.html" accesskey="p" rel="prev">Advanced Interface</a>, Up: <a href="Advanced-Interface.html" accesskey="u" rel="up">Advanced Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

91
fftw-3.3.10/doc/html/Advanced-Interface.html Normal file
View File

@@ -0,0 +1,91 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Advanced Interface (FFTW 3.3.10)</title>
<meta name="description" content="Advanced Interface (FFTW 3.3.10)">
<meta name="keywords" content="Advanced Interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-Reference.html" rel="up" title="FFTW Reference">
<link href="Advanced-Complex-DFTs.html" rel="next" title="Advanced Complex DFTs">
<link href="Real_002dto_002dReal-Transform-Kinds.html" rel="prev" title="Real-to-Real Transform Kinds">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Advanced-Interface"></span><div class="header">
<p>
Next: <a href="Guru-Interface.html" accesskey="n" rel="next">Guru Interface</a>, Previous: <a href="Basic-Interface.html" accesskey="p" rel="prev">Basic Interface</a>, Up: <a href="FFTW-Reference.html" accesskey="u" rel="up">FFTW Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Advanced-Interface-1"></span><h3 class="section">4.4 Advanced Interface</h3>
<span id="index-advanced-interface-3"></span>
<p>FFTW&rsquo;s &ldquo;advanced&rdquo; interface supplements the basic interface with four
new planner routines, providing a new level of flexibility: you can plan
a transform of multiple arrays simultaneously, operate on non-contiguous
(strided) data, and transform a subset of a larger multi-dimensional
array. Other than these additional features, the planner operates in
the same fashion as in the basic interface, and the resulting
<code>fftw_plan</code> is used in the same way (see <a href="Using-Plans.html">Using Plans</a>).
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Advanced-Complex-DFTs.html" accesskey="1">Advanced Complex DFTs</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Advanced-Real_002ddata-DFTs.html" accesskey="2">Advanced Real-data DFTs</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Advanced-Real_002dto_002dreal-Transforms.html" accesskey="3">Advanced Real-to-real Transforms</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

122
fftw-3.3.10/doc/html/Advanced-Real_002ddata-DFTs.html Normal file
View File

@@ -0,0 +1,122 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Advanced Real-data DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Advanced Real-data DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Advanced Real-data DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Advanced-Interface.html" rel="up" title="Advanced Interface">
<link href="Advanced-Real_002dto_002dreal-Transforms.html" rel="next" title="Advanced Real-to-real Transforms">
<link href="Advanced-Complex-DFTs.html" rel="prev" title="Advanced Complex DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Advanced-Real_002ddata-DFTs"></span><div class="header">
<p>
Next: <a href="Advanced-Real_002dto_002dreal-Transforms.html" accesskey="n" rel="next">Advanced Real-to-real Transforms</a>, Previous: <a href="Advanced-Complex-DFTs.html" accesskey="p" rel="prev">Advanced Complex DFTs</a>, Up: <a href="Advanced-Interface.html" accesskey="u" rel="up">Advanced Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Advanced-Real_002ddata-DFTs-1"></span><h4 class="subsection">4.4.2 Advanced Real-data DFTs</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_many_dft_r2c(int rank, const int *n, int howmany,
double *in, const int *inembed,
int istride, int idist,
fftw_complex *out, const int *onembed,
int ostride, int odist,
unsigned flags);
fftw_plan fftw_plan_many_dft_c2r(int rank, const int *n, int howmany,
fftw_complex *in, const int *inembed,
int istride, int idist,
double *out, const int *onembed,
int ostride, int odist,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fmany_005fdft_005fr2c"></span>
<span id="index-fftw_005fplan_005fmany_005fdft_005fc2r"></span>
<p>Like <code>fftw_plan_many_dft</code>, these two functions add <code>howmany</code>,
<code>nembed</code>, <code>stride</code>, and <code>dist</code> parameters to the
<code>fftw_plan_dft_r2c</code> and <code>fftw_plan_dft_c2r</code> functions, but
otherwise behave the same as the basic interface.
</p>
<p>The interpretation of <code>howmany</code>, <code>stride</code>, and <code>dist</code> are
the same as for <code>fftw_plan_many_dft</code>, above. Note that the
<code>stride</code> and <code>dist</code> for the real array are in units of
<code>double</code>, and for the complex array are in units of
<code>fftw_complex</code>.
</p>
<p>If an <code>nembed</code> parameter is <code>NULL</code>, it is interpreted as what
it would be in the basic interface, as described in <a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a>. That is, for the complex array the size is assumed to be
the same as <code>n</code>, but with the last dimension cut roughly in half.
For the real array, the size is assumed to be <code>n</code> if the transform
is out-of-place, or <code>n</code> with the last dimension &ldquo;padded&rdquo; if the
transform is in-place.
</p>
<p>If an <code>nembed</code> parameter is non-<code>NULL</code>, it is interpreted as
the physical size of the corresponding array, in row-major order, just
as for <code>fftw_plan_many_dft</code>. In this case, each dimension of
<code>nembed</code> should be <code>&gt;=</code> what it would be in the basic
interface (e.g. the halved or padded <code>n</code>).
</p>
<p>Arrays <code>n</code>, <code>inembed</code>, and <code>onembed</code> are not used after
this function returns. You can safely free or reuse them.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Advanced-Real_002dto_002dreal-Transforms.html" accesskey="n" rel="next">Advanced Real-to-real Transforms</a>, Previous: <a href="Advanced-Complex-DFTs.html" accesskey="p" rel="prev">Advanced Complex DFTs</a>, Up: <a href="Advanced-Interface.html" accesskey="u" rel="up">Advanced Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

94
fftw-3.3.10/doc/html/Advanced-Real_002dto_002dreal-Transforms.html Normal file
View File

@@ -0,0 +1,94 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Advanced Real-to-real Transforms (FFTW 3.3.10)</title>
<meta name="description" content="Advanced Real-to-real Transforms (FFTW 3.3.10)">
<meta name="keywords" content="Advanced Real-to-real Transforms (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Advanced-Interface.html" rel="up" title="Advanced Interface">
<link href="Guru-Interface.html" rel="next" title="Guru Interface">
<link href="Advanced-Real_002ddata-DFTs.html" rel="prev" title="Advanced Real-data DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Advanced-Real_002dto_002dreal-Transforms"></span><div class="header">
<p>
Previous: <a href="Advanced-Real_002ddata-DFTs.html" accesskey="p" rel="prev">Advanced Real-data DFTs</a>, Up: <a href="Advanced-Interface.html" accesskey="u" rel="up">Advanced Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Advanced-Real_002dto_002dreal-Transforms-1"></span><h4 class="subsection">4.4.3 Advanced Real-to-real Transforms</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_many_r2r(int rank, const int *n, int howmany,
double *in, const int *inembed,
int istride, int idist,
double *out, const int *onembed,
int ostride, int odist,
const fftw_r2r_kind *kind, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fmany_005fr2r"></span>
<p>Like <code>fftw_plan_many_dft</code>, this functions adds <code>howmany</code>,
<code>nembed</code>, <code>stride</code>, and <code>dist</code> parameters to the
<code>fftw_plan_r2r</code> function, but otherwise behave the same as the
basic interface. The interpretation of those additional parameters are
the same as for <code>fftw_plan_many_dft</code>. (Of course, the
<code>stride</code> and <code>dist</code> parameters are now in units of
<code>double</code>, not <code>fftw_complex</code>.)
</p>
<p>Arrays <code>n</code>, <code>inembed</code>, <code>onembed</code>, and <code>kind</code> are not
used after this function returns. You can safely free or reuse them.
</p>
</body>
</html>

97
fftw-3.3.10/doc/html/Advanced-distributed_002dtranspose-interface.html Normal file
View File

@@ -0,0 +1,97 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Advanced distributed-transpose interface (FFTW 3.3.10)</title>
<meta name="description" content="Advanced distributed-transpose interface (FFTW 3.3.10)">
<meta name="keywords" content="Advanced distributed-transpose interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Transposes.html" rel="up" title="FFTW MPI Transposes">
<link href="An-improved-replacement-for-MPI_005fAlltoall.html" rel="next" title="An improved replacement for MPI_Alltoall">
<link href="Basic-distributed_002dtranspose-interface.html" rel="prev" title="Basic distributed-transpose interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Advanced-distributed_002dtranspose-interface"></span><div class="header">
<p>
Next: <a href="An-improved-replacement-for-MPI_005fAlltoall.html" accesskey="n" rel="next">An improved replacement for MPI_Alltoall</a>, Previous: <a href="Basic-distributed_002dtranspose-interface.html" accesskey="p" rel="prev">Basic distributed-transpose interface</a>, Up: <a href="FFTW-MPI-Transposes.html" accesskey="u" rel="up">FFTW MPI Transposes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Advanced-distributed_002dtranspose-interface-1"></span><h4 class="subsection">6.7.2 Advanced distributed-transpose interface</h4>
<p>The above routines are for a transpose of a matrix of numbers (of type
<code>double</code>), using FFTW&rsquo;s default block sizes. More generally, one
can perform transposes of <em>tuples</em> of numbers, with
user-specified block sizes for the input and output:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_mpi_plan_many_transpose
(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t howmany,
ptrdiff_t block0, ptrdiff_t block1,
double *in, double *out, MPI_Comm comm, unsigned flags);
</pre></div>
<span id="index-fftw_005fmpi_005fplan_005fmany_005ftranspose"></span>
<p>In this case, one is transposing an <code>n0</code> by <code>n1</code> matrix of
<code>howmany</code>-tuples (e.g. <code>howmany = 2</code> for complex numbers).
The input is distributed along the <code>n0</code> dimension with block size
<code>block0</code>, and the <code>n1</code> by <code>n0</code> output is distributed
along the <code>n1</code> dimension with block size <code>block1</code>. If
<code>FFTW_MPI_DEFAULT_BLOCK</code> (0) is passed for a block size then FFTW
uses its default block size. To get the local size of the data on
each process, you should then call <code>fftw_mpi_local_size_many_transposed</code>.
<span id="index-FFTW_005fMPI_005fDEFAULT_005fBLOCK-1"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005fmany_005ftransposed"></span>
</p>
</body>
</html>

157
fftw-3.3.10/doc/html/Allocating-aligned-memory-in-Fortran.html Normal file
View File

@@ -0,0 +1,157 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Allocating aligned memory in Fortran (FFTW 3.3.10)</title>
<meta name="description" content="Allocating aligned memory in Fortran (FFTW 3.3.10)">
<meta name="keywords" content="Allocating aligned memory in Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="up" title="Calling FFTW from Modern Fortran">
<link href="Accessing-the-wisdom-API-from-Fortran.html" rel="next" title="Accessing the wisdom API from Fortran">
<link href="Plan-execution-in-Fortran.html" rel="prev" title="Plan execution in Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Allocating-aligned-memory-in-Fortran"></span><div class="header">
<p>
Next: <a href="Accessing-the-wisdom-API-from-Fortran.html" accesskey="n" rel="next">Accessing the wisdom API from Fortran</a>, Previous: <a href="Plan-execution-in-Fortran.html" accesskey="p" rel="prev">Plan execution in Fortran</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Allocating-aligned-memory-in-Fortran-1"></span><h3 class="section">7.5 Allocating aligned memory in Fortran</h3>
<span id="index-alignment-5"></span>
<span id="index-fftw_005falloc_005freal-5"></span>
<span id="index-fftw_005falloc_005fcomplex-5"></span>
<p>In order to obtain maximum performance in FFTW, you should store your
data in arrays that have been specially aligned in memory (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>). Enforcing alignment also permits you to
safely use the new-array execute functions (see <a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a>) to apply a given plan to more than one pair of in/out
arrays. Unfortunately, standard Fortran arrays do <em>not</em> provide
any alignment guarantees. The <em>only</em> way to allocate aligned
memory in standard Fortran is to allocate it with an external C
function, like the <code>fftw_alloc_real</code> and
<code>fftw_alloc_complex</code> functions. Fortunately, Fortran 2003 provides
a simple way to associate such allocated memory with a standard Fortran
array pointer that you can then use normally.
</p>
<p>We therefore recommend allocating all your input/output arrays using
the following technique:
</p>
<ol>
<li> Declare a <code>pointer</code>, <code>arr</code>, to your array of the desired type
and dimensions. For example, <code>real(C_DOUBLE), pointer :: a(:,:)</code>
for a 2d real array, or <code>complex(C_DOUBLE_COMPLEX), pointer ::
a(:,:,:)</code> for a 3d complex array.
</li><li> The number of elements to allocate must be an
<code>integer(C_SIZE_T)</code>. You can either declare a variable of this
type, e.g. <code>integer(C_SIZE_T) :: sz</code>, to store the number of
elements to allocate, or you can use the <code>int(..., C_SIZE_T)</code>
intrinsic function. e.g. set <code>sz = L * M * N</code> or use
<code>int(L * M * N, C_SIZE_T)</code> for an L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
array.
</li><li> Declare a <code>type(C_PTR) :: p</code> to hold the return value from
FFTW&rsquo;s allocation routine. Set <code>p = fftw_alloc_real(sz)</code> for a real array, or <code>p = fftw_alloc_complex(sz)</code> for a complex array.
</li><li> <span id="index-c_005ff_005fpointer-2"></span>
Associate your pointer <code>arr</code> with the allocated memory <code>p</code>
using the standard <code>c_f_pointer</code> subroutine: <code>call
c_f_pointer(p, arr, [...dimensions...])</code>, where
<code>[...dimensions...])</code> are an array of the dimensions of the array
(in the usual Fortran order). e.g. <code>call c_f_pointer(p, arr,
[L,M,N])</code> for an L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
array. (Alternatively, you can
omit the dimensions argument if you specified the shape explicitly
when declaring <code>arr</code>.) You can now use <code>arr</code> as a usual
multidimensional array.
</li><li> When you are done using the array, deallocate the memory by <code>call
fftw_free(p)</code> on <code>p</code>.
</li></ol>
<p>For example, here is how we would allocate an L&nbsp;&times;&nbsp;M
2d real array:
</p>
<div class="example">
<pre class="example"> real(C_DOUBLE), pointer :: arr(:,:)
type(C_PTR) :: p
p = fftw_alloc_real(int(L * M, C_SIZE_T))
call c_f_pointer(p, arr, [L,M])
<em>...use arr and arr(i,j) as usual...</em>
call fftw_free(p)
</pre></div>
<p>and here is an L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
3d complex array:
</p>
<div class="example">
<pre class="example"> complex(C_DOUBLE_COMPLEX), pointer :: arr(:,:,:)
type(C_PTR) :: p
p = fftw_alloc_complex(int(L * M * N, C_SIZE_T))
call c_f_pointer(p, arr, [L,M,N])
<em>...use arr and arr(i,j,k) as usual...</em>
call fftw_free(p)
</pre></div>
<p>See <a href="Reversing-array-dimensions.html">Reversing array dimensions</a> for an example allocating a
single array and associating both real and complex array pointers with
it, for in-place real-to-complex transforms.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Accessing-the-wisdom-API-from-Fortran.html" accesskey="n" rel="next">Accessing the wisdom API from Fortran</a>, Previous: <a href="Plan-execution-in-Fortran.html" accesskey="p" rel="prev">Plan execution in Fortran</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

127
fftw-3.3.10/doc/html/An-improved-replacement-for-MPI_005fAlltoall.html Normal file
View File

@@ -0,0 +1,127 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>An improved replacement for MPI_Alltoall (FFTW 3.3.10)</title>
<meta name="description" content="An improved replacement for MPI_Alltoall (FFTW 3.3.10)">
<meta name="keywords" content="An improved replacement for MPI_Alltoall (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Transposes.html" rel="up" title="FFTW MPI Transposes">
<link href="FFTW-MPI-Wisdom.html" rel="next" title="FFTW MPI Wisdom">
<link href="Advanced-distributed_002dtranspose-interface.html" rel="prev" title="Advanced distributed-transpose interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="An-improved-replacement-for-MPI_005fAlltoall"></span><div class="header">
<p>
Previous: <a href="Advanced-distributed_002dtranspose-interface.html" accesskey="p" rel="prev">Advanced distributed-transpose interface</a>, Up: <a href="FFTW-MPI-Transposes.html" accesskey="u" rel="up">FFTW MPI Transposes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="An-improved-replacement-for-MPI_005fAlltoall-1"></span><h4 class="subsection">6.7.3 An improved replacement for MPI_Alltoall</h4>
<p>We close this section by noting that FFTW&rsquo;s MPI transpose routines can
be thought of as a generalization for the <code>MPI_Alltoall</code> function
(albeit only for floating-point types), and in some circumstances can
function as an improved replacement.
<span id="index-MPI_005fAlltoall"></span>
</p>
<p><code>MPI_Alltoall</code> is defined by the MPI standard as:
</p>
<div class="example">
<pre class="example">int MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype,
void *recvbuf, int recvcnt, MPI_Datatype recvtype,
MPI_Comm comm);
</pre></div>
<p>In particular, for <code>double*</code> arrays <code>in</code> and <code>out</code>,
consider the call:
</p>
<div class="example">
<pre class="example">MPI_Alltoall(in, howmany, MPI_DOUBLE, out, howmany MPI_DOUBLE, comm);
</pre></div>
<p>This is completely equivalent to:
</p>
<div class="example">
<pre class="example">MPI_Comm_size(comm, &amp;P);
plan = fftw_mpi_plan_many_transpose(P, P, howmany, 1, 1, in, out, comm, FFTW_ESTIMATE);
fftw_execute(plan);
fftw_destroy_plan(plan);
</pre></div>
<p>That is, computing a P&nbsp;&times;&nbsp;P
transpose on <code>P</code> processes,
with a block size of 1, is just a standard all-to-all communication.
</p>
<p>However, using the FFTW routine instead of <code>MPI_Alltoall</code> may
have certain advantages. First of all, FFTW&rsquo;s routine can operate
in-place (<code>in == out</code>) whereas <code>MPI_Alltoall</code> can only
operate out-of-place.
<span id="index-in_002dplace-8"></span>
</p>
<p>Second, even for out-of-place plans, FFTW&rsquo;s routine may be faster,
especially if you need to perform the all-to-all communication many
times and can afford to use <code>FFTW_MEASURE</code> or
<code>FFTW_PATIENT</code>. It should certainly be no slower, not including
the time to create the plan, since one of the possible algorithms that
FFTW uses for an out-of-place transpose <em>is</em> simply to call
<code>MPI_Alltoall</code>. However, FFTW also considers several other
possible algorithms that, depending on your MPI implementation and
your hardware, may be faster.
<span id="index-FFTW_005fMEASURE-3"></span>
<span id="index-FFTW_005fPATIENT-4"></span>
</p>
</body>
</html>

96
fftw-3.3.10/doc/html/Avoiding-MPI-Deadlocks.html Normal file
View File

@@ -0,0 +1,96 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Avoiding MPI Deadlocks (FFTW 3.3.10)</title>
<meta name="description" content="Avoiding MPI Deadlocks (FFTW 3.3.10)">
<meta name="keywords" content="Avoiding MPI Deadlocks (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="FFTW-MPI-Performance-Tips.html" rel="next" title="FFTW MPI Performance Tips">
<link href="FFTW-MPI-Wisdom.html" rel="prev" title="FFTW MPI Wisdom">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Avoiding-MPI-Deadlocks"></span><div class="header">
<p>
Next: <a href="FFTW-MPI-Performance-Tips.html" accesskey="n" rel="next">FFTW MPI Performance Tips</a>, Previous: <a href="FFTW-MPI-Wisdom.html" accesskey="p" rel="prev">FFTW MPI Wisdom</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Avoiding-MPI-Deadlocks-1"></span><h3 class="section">6.9 Avoiding MPI Deadlocks</h3>
<span id="index-deadlock"></span>
<p>An MPI program can <em>deadlock</em> if one process is waiting for a
message from another process that never gets sent. To avoid deadlocks
when using FFTW&rsquo;s MPI routines, it is important to know which
functions are <em>collective</em>: that is, which functions must
<em>always</em> be called in the <em>same order</em> from <em>every</em>
process in a given communicator. (For example, <code>MPI_Barrier</code> is
the canonical example of a collective function in the MPI standard.)
<span id="index-collective-function-2"></span>
<span id="index-MPI_005fBarrier"></span>
</p>
<p>The functions in FFTW that are <em>always</em> collective are: every
function beginning with &lsquo;<samp>fftw_mpi_plan</samp>&rsquo;, as well as
<code>fftw_mpi_broadcast_wisdom</code> and <code>fftw_mpi_gather_wisdom</code>.
Also, the following functions from the ordinary FFTW interface are
collective when they are applied to a plan created by an
&lsquo;<samp>fftw_mpi_plan</samp>&rsquo; function: <code>fftw_execute</code>,
<code>fftw_destroy_plan</code>, and <code>fftw_flops</code>.
<span id="index-fftw_005fexecute-4"></span>
<span id="index-fftw_005fdestroy_005fplan-2"></span>
<span id="index-fftw_005fflops-1"></span>
</p>
</body>
</html>

104
fftw-3.3.10/doc/html/Basic-Interface.html Normal file
View File

@@ -0,0 +1,104 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Basic Interface (FFTW 3.3.10)</title>
<meta name="description" content="Basic Interface (FFTW 3.3.10)">
<meta name="keywords" content="Basic Interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-Reference.html" rel="up" title="FFTW Reference">
<link href="Complex-DFTs.html" rel="next" title="Complex DFTs">
<link href="Using-Plans.html" rel="prev" title="Using Plans">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Basic-Interface"></span><div class="header">
<p>
Next: <a href="Advanced-Interface.html" accesskey="n" rel="next">Advanced Interface</a>, Previous: <a href="Using-Plans.html" accesskey="p" rel="prev">Using Plans</a>, Up: <a href="FFTW-Reference.html" accesskey="u" rel="up">FFTW Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Basic-Interface-1"></span><h3 class="section">4.3 Basic Interface</h3>
<span id="index-basic-interface-2"></span>
<p>Recall that the FFTW API is divided into three parts<a id="DOCF6" href="#FOOT6"><sup>6</sup></a>: the <em>basic interface</em>
computes a single transform of contiguous data, the <em>advanced
interface</em> computes transforms of multiple or strided arrays, and the
<em>guru interface</em> supports the most general data layouts,
multiplicities, and strides. This section describes the basic
interface, which we expect to satisfy the needs of most users.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Complex-DFTs.html" accesskey="1">Complex DFTs</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Planner-Flags.html" accesskey="2">Planner Flags</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Real_002ddata-DFTs.html" accesskey="3">Real-data DFTs</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Real_002ddata-DFT-Array-Format.html" accesskey="4">Real-data DFT Array Format</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Real_002dto_002dReal-Transforms.html" accesskey="5">Real-to-Real Transforms</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Real_002dto_002dReal-Transform-Kinds.html" accesskey="6">Real-to-Real Transform Kinds</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<div class="footnote">
<hr>
<h4 class="footnotes-heading">Footnotes</h4>
<h5><a id="FOOT6" href="#DOCF6">(6)</a></h3>
<p><i>Gallia est
omnis divisa in partes tres</i> (Julius Caesar).</p>
</div>
</body>
</html>

177
fftw-3.3.10/doc/html/Basic-and-advanced-distribution-interfaces.html Normal file
View File

@@ -0,0 +1,177 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Basic and advanced distribution interfaces (FFTW 3.3.10)</title>
<meta name="description" content="Basic and advanced distribution interfaces (FFTW 3.3.10)">
<meta name="keywords" content="Basic and advanced distribution interfaces (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="MPI-Data-Distribution.html" rel="up" title="MPI Data Distribution">
<link href="Load-balancing.html" rel="next" title="Load balancing">
<link href="MPI-Data-Distribution.html" rel="prev" title="MPI Data Distribution">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Basic-and-advanced-distribution-interfaces"></span><div class="header">
<p>
Next: <a href="Load-balancing.html" accesskey="n" rel="next">Load balancing</a>, Previous: <a href="MPI-Data-Distribution.html" accesskey="p" rel="prev">MPI Data Distribution</a>, Up: <a href="MPI-Data-Distribution.html" accesskey="u" rel="up">MPI Data Distribution</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Basic-and-advanced-distribution-interfaces-1"></span><h4 class="subsection">6.4.1 Basic and advanced distribution interfaces</h4>
<p>As with the planner interface, the &lsquo;<samp>fftw_mpi_local_size</samp>&rsquo;
distribution interface is broken into basic and advanced
(&lsquo;<samp>_many</samp>&rsquo;) interfaces, where the latter allows you to specify the
block size manually and also to request block sizes when computing
multiple transforms simultaneously. These functions are documented
more exhaustively by the FFTW MPI Reference, but we summarize the
basic ideas here using a couple of two-dimensional examples.
</p>
<p>For the 100&nbsp;&times;&nbsp;200
complex-DFT example, above, we would find
the distribution by calling the following function in the basic
interface:
</p>
<div class="example">
<pre class="example">ptrdiff_t fftw_mpi_local_size_2d(ptrdiff_t n0, ptrdiff_t n1, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start);
</pre></div>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f2d-1"></span>
<p>Given the total size of the data to be transformed (here, <code>n0 =
100</code> and <code>n1 = 200</code>) and an MPI communicator (<code>comm</code>), this
function provides three numbers.
</p>
<p>First, it describes the shape of the local data: the current process
should store a <code>local_n0</code> by <code>n1</code> slice of the overall
dataset, in row-major order (<code>n1</code> dimension contiguous), starting
at index <code>local_0_start</code>. That is, if the total dataset is
viewed as a <code>n0</code> by <code>n1</code> matrix, the current process should
store the rows <code>local_0_start</code> to
<code>local_0_start+local_n0-1</code>. Obviously, if you are running with
only a single MPI process, that process will store the entire array:
<code>local_0_start</code> will be zero and <code>local_n0</code> will be
<code>n0</code>. See <a href="Row_002dmajor-Format.html">Row-major Format</a>.
<span id="index-row_002dmajor-4"></span>
</p>
<p>Second, the return value is the total number of data elements (e.g.,
complex numbers for a complex DFT) that should be allocated for the
input and output arrays on the current process (ideally with
<code>fftw_malloc</code> or an &lsquo;<samp>fftw_alloc</samp>&rsquo; function, to ensure optimal
alignment). It might seem that this should always be equal to
<code>local_n0 * n1</code>, but this is <em>not</em> the case. FFTW&rsquo;s
distributed FFT algorithms require data redistributions at
intermediate stages of the transform, and in some circumstances this
may require slightly larger local storage. This is discussed in more
detail below, under <a href="Load-balancing.html">Load balancing</a>.
<span id="index-fftw_005fmalloc-5"></span>
<span id="index-fftw_005falloc_005fcomplex-3"></span>
</p>
<span id="index-advanced-interface-4"></span>
<p>The advanced-interface &lsquo;<samp>local_size</samp>&rsquo; function for multidimensional
transforms returns the same three things (<code>local_n0</code>,
<code>local_0_start</code>, and the total number of elements to allocate),
but takes more inputs:
</p>
<div class="example">
<pre class="example">ptrdiff_t fftw_mpi_local_size_many(int rnk, const ptrdiff_t *n,
ptrdiff_t howmany,
ptrdiff_t block0,
MPI_Comm comm,
ptrdiff_t *local_n0,
ptrdiff_t *local_0_start);
</pre></div>
<span id="index-fftw_005fmpi_005flocal_005fsize_005fmany"></span>
<p>The two-dimensional case above corresponds to <code>rnk = 2</code> and an
array <code>n</code> of length 2 with <code>n[0] = n0</code> and <code>n[1] = n1</code>.
This routine is for any <code>rnk &gt; 1</code>; one-dimensional transforms
have their own interface because they work slightly differently, as
discussed below.
</p>
<p>First, the advanced interface allows you to perform multiple
transforms at once, of interleaved data, as specified by the
<code>howmany</code> parameter. (<code>hoamany</code> is 1 for a single
transform.)
</p>
<p>Second, here you can specify your desired block size in the <code>n0</code>
dimension, <code>block0</code>. To use FFTW&rsquo;s default block size, pass
<code>FFTW_MPI_DEFAULT_BLOCK</code> (0) for <code>block0</code>. Otherwise, on
<code>P</code> processes, FFTW will return <code>local_n0</code> equal to
<code>block0</code> on the first <code>P / block0</code> processes (rounded down),
return <code>local_n0</code> equal to <code>n0 - block0 * (P / block0)</code> on
the next process, and <code>local_n0</code> equal to zero on any remaining
processes. In general, we recommend using the default block size
(which corresponds to <code>n0 / P</code>, rounded up).
<span id="index-FFTW_005fMPI_005fDEFAULT_005fBLOCK"></span>
<span id="index-block-distribution-1"></span>
</p>
<p>For example, suppose you have <code>P = 4</code> processes and <code>n0 =
21</code>. The default will be a block size of <code>6</code>, which will give
<code>local_n0 = 6</code> on the first three processes and <code>local_n0 =
3</code> on the last process. Instead, however, you could specify
<code>block0 = 5</code> if you wanted, which would give <code>local_n0 = 5</code>
on processes 0 to 2, <code>local_n0 = 6</code> on process 3. (This choice,
while it may look superficially more &ldquo;balanced,&rdquo; has the same
critical path as FFTW&rsquo;s default but requires more communications.)
</p>
<hr>
<div class="header">
<p>
Next: <a href="Load-balancing.html" accesskey="n" rel="next">Load balancing</a>, Previous: <a href="MPI-Data-Distribution.html" accesskey="p" rel="prev">MPI Data Distribution</a>, Up: <a href="MPI-Data-Distribution.html" accesskey="u" rel="up">MPI Data Distribution</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

129
fftw-3.3.10/doc/html/Basic-distributed_002dtranspose-interface.html Normal file
View File

@@ -0,0 +1,129 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Basic distributed-transpose interface (FFTW 3.3.10)</title>
<meta name="description" content="Basic distributed-transpose interface (FFTW 3.3.10)">
<meta name="keywords" content="Basic distributed-transpose interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Transposes.html" rel="up" title="FFTW MPI Transposes">
<link href="Advanced-distributed_002dtranspose-interface.html" rel="next" title="Advanced distributed-transpose interface">
<link href="FFTW-MPI-Transposes.html" rel="prev" title="FFTW MPI Transposes">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Basic-distributed_002dtranspose-interface"></span><div class="header">
<p>
Next: <a href="Advanced-distributed_002dtranspose-interface.html" accesskey="n" rel="next">Advanced distributed-transpose interface</a>, Previous: <a href="FFTW-MPI-Transposes.html" accesskey="p" rel="prev">FFTW MPI Transposes</a>, Up: <a href="FFTW-MPI-Transposes.html" accesskey="u" rel="up">FFTW MPI Transposes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Basic-distributed_002dtranspose-interface-1"></span><h4 class="subsection">6.7.1 Basic distributed-transpose interface</h4>
<p>In particular, suppose that we have an <code>n0</code> by <code>n1</code> array in
row-major order, block-distributed across the <code>n0</code> dimension. To
transpose this into an <code>n1</code> by <code>n0</code> array block-distributed
across the <code>n1</code> dimension, we would create a plan by calling the
following function:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_mpi_plan_transpose(ptrdiff_t n0, ptrdiff_t n1,
double *in, double *out,
MPI_Comm comm, unsigned flags);
</pre></div>
<span id="index-fftw_005fmpi_005fplan_005ftranspose"></span>
<p>The input and output arrays (<code>in</code> and <code>out</code>) can be the
same. The transpose is actually executed by calling
<code>fftw_execute</code> on the plan, as usual.
<span id="index-fftw_005fexecute-3"></span>
</p>
<p>The <code>flags</code> are the usual FFTW planner flags, but support
two additional flags: <code>FFTW_MPI_TRANSPOSED_OUT</code> and/or
<code>FFTW_MPI_TRANSPOSED_IN</code>. What these flags indicate, for
transpose plans, is that the output and/or input, respectively, are
<em>locally</em> transposed. That is, on each process input data is
normally stored as a <code>local_n0</code> by <code>n1</code> array in row-major
order, but for an <code>FFTW_MPI_TRANSPOSED_IN</code> plan the input data is
stored as <code>n1</code> by <code>local_n0</code> in row-major order. Similarly,
<code>FFTW_MPI_TRANSPOSED_OUT</code> means that the output is <code>n0</code> by
<code>local_n1</code> instead of <code>local_n1</code> by <code>n0</code>.
<span id="index-FFTW_005fMPI_005fTRANSPOSED_005fOUT-1"></span>
<span id="index-FFTW_005fMPI_005fTRANSPOSED_005fIN-1"></span>
</p>
<p>To determine the local size of the array on each process before and
after the transpose, as well as the amount of storage that must be
allocated, one should call <code>fftw_mpi_local_size_2d_transposed</code>,
just as for a 2d DFT as described in the previous section:
<span id="index-data-distribution-4"></span>
</p>
<div class="example">
<pre class="example">ptrdiff_t fftw_mpi_local_size_2d_transposed
(ptrdiff_t n0, ptrdiff_t n1, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start,
ptrdiff_t *local_n1, ptrdiff_t *local_1_start);
</pre></div>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f2d_005ftransposed"></span>
<p>Again, the return value is the local storage to allocate, which in
this case is the number of <em>real</em> (<code>double</code>) values rather
than complex numbers as in the previous examples.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Advanced-distributed_002dtranspose-interface.html" accesskey="n" rel="next">Advanced distributed-transpose interface</a>, Previous: <a href="FFTW-MPI-Transposes.html" accesskey="p" rel="prev">FFTW MPI Transposes</a>, Up: <a href="FFTW-MPI-Transposes.html" accesskey="u" rel="up">FFTW MPI Transposes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

115
fftw-3.3.10/doc/html/Calling-FFTW-from-Legacy-Fortran.html Normal file
View File

@@ -0,0 +1,115 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Calling FFTW from Legacy Fortran (FFTW 3.3.10)</title>
<meta name="description" content="Calling FFTW from Legacy Fortran (FFTW 3.3.10)">
<meta name="keywords" content="Calling FFTW from Legacy Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Fortran_002dinterface-routines.html" rel="next" title="Fortran-interface routines">
<link href="Defining-an-FFTW-module.html" rel="prev" title="Defining an FFTW module">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Calling-FFTW-from-Legacy-Fortran"></span><div class="header">
<p>
Next: <a href="Upgrading-from-FFTW-version-2.html" accesskey="n" rel="next">Upgrading from FFTW version 2</a>, Previous: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="p" rel="prev">Calling FFTW from Modern Fortran</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Calling-FFTW-from-Legacy-Fortran-1"></span><h2 class="chapter">8 Calling FFTW from Legacy Fortran</h2>
<span id="index-Fortran-interface-3"></span>
<p>This chapter describes the interface to FFTW callable by Fortran code
in older compilers not supporting the Fortran 2003 C interoperability
features (see <a href="Calling-FFTW-from-Modern-Fortran.html">Calling FFTW from Modern Fortran</a>). This interface
has the major disadvantage that it is not type-checked, so if you
mistake the argument types or ordering then your program will not have
any compiler errors, and will likely crash at runtime. So, greater
care is needed. Also, technically interfacing older Fortran versions
to C is nonstandard, but in practice we have found that the techniques
used in this chapter have worked with all known Fortran compilers for
many years.
</p>
<p>The legacy Fortran interface differs from the C interface only in the
prefix (&lsquo;<samp>dfftw_</samp>&rsquo; instead of &lsquo;<samp>fftw_</samp>&rsquo; in double precision) and
a few other minor details. This Fortran interface is included in the
FFTW libraries by default, unless a Fortran compiler isn&rsquo;t found on
your system or <code>--disable-fortran</code> is included in the
<code>configure</code> flags. We assume here that the reader is already
familiar with the usage of FFTW in C, as described elsewhere in this
manual.
</p>
<p>The MPI parallel interface to FFTW is <em>not</em> currently available
to legacy Fortran.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Fortran_002dinterface-routines.html" accesskey="1">Fortran-interface routines</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-Constants-in-Fortran.html" accesskey="2">FFTW Constants in Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-Execution-in-Fortran.html" accesskey="3">FFTW Execution in Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Fortran-Examples.html" accesskey="4">Fortran Examples</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Wisdom-of-Fortran_003f.html" accesskey="5">Wisdom of Fortran?</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<hr>
<div class="header">
<p>
Next: <a href="Upgrading-from-FFTW-version-2.html" accesskey="n" rel="next">Upgrading from FFTW version 2</a>, Previous: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="p" rel="prev">Calling FFTW from Modern Fortran</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

108
fftw-3.3.10/doc/html/Calling-FFTW-from-Modern-Fortran.html Normal file
View File

@@ -0,0 +1,108 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Calling FFTW from Modern Fortran (FFTW 3.3.10)</title>
<meta name="description" content="Calling FFTW from Modern Fortran (FFTW 3.3.10)">
<meta name="keywords" content="Calling FFTW from Modern Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Overview-of-Fortran-interface.html" rel="next" title="Overview of Fortran interface">
<link href="FFTW-MPI-Fortran-Interface.html" rel="prev" title="FFTW MPI Fortran Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Calling-FFTW-from-Modern-Fortran"></span><div class="header">
<p>
Next: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="n" rel="next">Calling FFTW from Legacy Fortran</a>, Previous: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="p" rel="prev">Distributed-memory FFTW with MPI</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Calling-FFTW-from-Modern-Fortran-1"></span><h2 class="chapter">7 Calling FFTW from Modern Fortran</h2>
<span id="index-Fortran-interface-2"></span>
<p>Fortran 2003 standardized ways for Fortran code to call C libraries,
and this allows us to support a direct translation of the FFTW C API
into Fortran. Compared to the legacy Fortran 77 interface
(see <a href="Calling-FFTW-from-Legacy-Fortran.html">Calling FFTW from Legacy Fortran</a>), this direct interface
offers many advantages, especially compile-time type-checking and
aligned memory allocation. As of this writing, support for these C
interoperability features seems widespread, having been implemented in
nearly all major Fortran compilers (e.g. GNU, Intel, IBM,
Oracle/Solaris, Portland Group, NAG).
<span id="index-portability-4"></span>
</p>
<p>This chapter documents that interface. For the most part, since this
interface allows Fortran to call the C interface directly, the usage
is identical to C translated to Fortran syntax. However, there are a
few subtle points such as memory allocation, wisdom, and data types
that deserve closer attention.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Overview-of-Fortran-interface.html" accesskey="1">Overview of Fortran interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Reversing-array-dimensions.html" accesskey="2">Reversing array dimensions</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-Fortran-type-reference.html" accesskey="3">FFTW Fortran type reference</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Plan-execution-in-Fortran.html" accesskey="4">Plan execution in Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Allocating-aligned-memory-in-Fortran.html" accesskey="5">Allocating aligned memory in Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Accessing-the-wisdom-API-from-Fortran.html" accesskey="6">Accessing the wisdom API from Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Defining-an-FFTW-module.html" accesskey="7">Defining an FFTW module</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

128
fftw-3.3.10/doc/html/Caveats-in-Using-Wisdom.html Normal file
View File

@@ -0,0 +1,128 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Caveats in Using Wisdom (FFTW 3.3.10)</title>
<meta name="description" content="Caveats in Using Wisdom (FFTW 3.3.10)">
<meta name="keywords" content="Caveats in Using Wisdom (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Other-Important-Topics.html" rel="up" title="Other Important Topics">
<link href="FFTW-Reference.html" rel="next" title="FFTW Reference">
<link href="Words-of-Wisdom_002dSaving-Plans.html" rel="prev" title="Words of Wisdom-Saving Plans">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Caveats-in-Using-Wisdom"></span><div class="header">
<p>
Previous: <a href="Words-of-Wisdom_002dSaving-Plans.html" accesskey="p" rel="prev">Words of Wisdom-Saving Plans</a>, Up: <a href="Other-Important-Topics.html" accesskey="u" rel="up">Other Important Topics</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Caveats-in-Using-Wisdom-1"></span><h3 class="section">3.4 Caveats in Using Wisdom</h3>
<span id="index-wisdom_002c-problems-with"></span>
<blockquote>
<i>
<p>For in much wisdom is much grief, and he that increaseth knowledge
increaseth sorrow.
</i>
[Ecclesiastes 1:18]
<span id="index-Ecclesiastes"></span>
</p></blockquote>
<span id="index-portability-1"></span>
<p>There are pitfalls to using wisdom, in that it can negate FFTW&rsquo;s
ability to adapt to changing hardware and other conditions. For
example, it would be perfectly possible to export wisdom from a
program running on one processor and import it into a program running
on another processor. Doing so, however, would mean that the second
program would use plans optimized for the first processor, instead of
the one it is running on.
</p>
<p>It should be safe to reuse wisdom as long as the hardware and program
binaries remain unchanged. (Actually, the optimal plan may change even
between runs of the same binary on identical hardware, due to
differences in the virtual memory environment, etcetera. Users
seriously interested in performance should worry about this problem,
too.) It is likely that, if the same wisdom is used for two
different program binaries, even running on the same machine, the
plans may be sub-optimal because of differing code alignments. It is
therefore wise to recreate wisdom every time an application is
recompiled. The more the underlying hardware and software changes
between the creation of wisdom and its use, the greater grows
the risk of sub-optimal plans.
</p>
<p>Nevertheless, if the choice is between using <code>FFTW_ESTIMATE</code> or
using possibly-suboptimal wisdom (created on the same machine, but for a
different binary), the wisdom is likely to be better. For this reason,
we provide a function to import wisdom from a standard system-wide
location (<code>/etc/fftw/wisdom</code> on Unix):
<span id="index-wisdom_002c-system_002dwide"></span>
</p>
<div class="example">
<pre class="example">int fftw_import_system_wisdom(void);
</pre></div>
<span id="index-fftw_005fimport_005fsystem_005fwisdom"></span>
<p>FFTW also provides a standalone program, <code>fftw-wisdom</code> (described
by its own <code>man</code> page on Unix) with which users can create wisdom,
e.g. for a canonical set of sizes to store in the system wisdom file.
See <a href="Wisdom-Utilities.html">Wisdom Utilities</a>.
<span id="index-fftw_002dwisdom-utility"></span>
</p>
<hr>
<div class="header">
<p>
Previous: <a href="Words-of-Wisdom_002dSaving-Plans.html" accesskey="p" rel="prev">Words of Wisdom-Saving Plans</a>, Up: <a href="Other-Important-Topics.html" accesskey="u" rel="up">Other Important Topics</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

91
fftw-3.3.10/doc/html/Column_002dmajor-Format.html Normal file
View File

@@ -0,0 +1,91 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Column-major Format (FFTW 3.3.10)</title>
<meta name="description" content="Column-major Format (FFTW 3.3.10)">
<meta name="keywords" content="Column-major Format (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Multi_002ddimensional-Array-Format.html" rel="up" title="Multi-dimensional Array Format">
<link href="Fixed_002dsize-Arrays-in-C.html" rel="next" title="Fixed-size Arrays in C">
<link href="Row_002dmajor-Format.html" rel="prev" title="Row-major Format">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Column_002dmajor-Format"></span><div class="header">
<p>
Next: <a href="Fixed_002dsize-Arrays-in-C.html" accesskey="n" rel="next">Fixed-size Arrays in C</a>, Previous: <a href="Row_002dmajor-Format.html" accesskey="p" rel="prev">Row-major Format</a>, Up: <a href="Multi_002ddimensional-Array-Format.html" accesskey="u" rel="up">Multi-dimensional Array Format</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Column_002dmajor-Format-1"></span><h4 class="subsection">3.2.2 Column-major Format</h4>
<span id="index-column_002dmajor"></span>
<p>Readers from the Fortran world are used to arrays stored in
<em>column-major</em> order (sometimes called &ldquo;Fortran order&rdquo;). This is
essentially the exact opposite of row-major order in that, here, the
<em>first</em> dimension&rsquo;s index varies most quickly.
</p>
<p>If you have an array stored in column-major order and wish to
transform it using FFTW, it is quite easy to do. When creating the
plan, simply pass the dimensions of the array to the planner in
<em>reverse order</em>. For example, if your array is a rank three
<code>N x M x L</code> matrix in column-major order, you should pass the
dimensions of the array as if it were an <code>L x M x N</code> matrix
(which it is, from the perspective of FFTW). This is done for you
<em>automatically</em> by the FFTW legacy-Fortran interface
(see <a href="Calling-FFTW-from-Legacy-Fortran.html">Calling FFTW from Legacy Fortran</a>), but you must do it
manually with the modern Fortran interface (see <a href="Reversing-array-dimensions.html">Reversing array dimensions</a>).
<span id="index-Fortran-interface"></span>
</p>
</body>
</html>

158
fftw-3.3.10/doc/html/Combining-MPI-and-Threads.html Normal file
View File

@@ -0,0 +1,158 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Combining MPI and Threads (FFTW 3.3.10)</title>
<meta name="description" content="Combining MPI and Threads (FFTW 3.3.10)">
<meta name="keywords" content="Combining MPI and Threads (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="FFTW-MPI-Reference.html" rel="next" title="FFTW MPI Reference">
<link href="FFTW-MPI-Performance-Tips.html" rel="prev" title="FFTW MPI Performance Tips">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Combining-MPI-and-Threads"></span><div class="header">
<p>
Next: <a href="FFTW-MPI-Reference.html" accesskey="n" rel="next">FFTW MPI Reference</a>, Previous: <a href="FFTW-MPI-Performance-Tips.html" accesskey="p" rel="prev">FFTW MPI Performance Tips</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Combining-MPI-and-Threads-1"></span><h3 class="section">6.11 Combining MPI and Threads</h3>
<span id="index-threads-2"></span>
<p>In certain cases, it may be advantageous to combine MPI
(distributed-memory) and threads (shared-memory) parallelization.
FFTW supports this, with certain caveats. For example, if you have a
cluster of 4-processor shared-memory nodes, you may want to use
threads within the nodes and MPI between the nodes, instead of MPI for
all parallelization.
</p>
<p>In particular, it is possible to seamlessly combine the MPI FFTW
routines with the multi-threaded FFTW routines (see <a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a>). However, some care must be taken in the initialization code,
which should look something like this:
</p>
<div class="example">
<pre class="example">int threads_ok;
int main(int argc, char **argv)
{
int provided;
MPI_Init_thread(&amp;argc, &amp;argv, MPI_THREAD_FUNNELED, &amp;provided);
threads_ok = provided &gt;= MPI_THREAD_FUNNELED;
if (threads_ok) threads_ok = fftw_init_threads();
fftw_mpi_init();
...
if (threads_ok) fftw_plan_with_nthreads(...);
...
MPI_Finalize();
}
</pre></div>
<span id="index-fftw_005fmpi_005finit-3"></span>
<span id="index-fftw_005finit_005fthreads-2"></span>
<span id="index-fftw_005fplan_005fwith_005fnthreads-1"></span>
<p>First, note that instead of calling <code>MPI_Init</code>, you should call
<code>MPI_Init_threads</code>, which is the initialization routine defined
by the MPI-2 standard to indicate to MPI that your program will be
multithreaded. We pass <code>MPI_THREAD_FUNNELED</code>, which indicates
that we will only call MPI routines from the main thread. (FFTW will
launch additional threads internally, but the extra threads will not
call MPI code.) (You may also pass <code>MPI_THREAD_SERIALIZED</code> or
<code>MPI_THREAD_MULTIPLE</code>, which requests additional multithreading
support from the MPI implementation, but this is not required by
FFTW.) The <code>provided</code> parameter returns what level of threads
support is actually supported by your MPI implementation; this
<em>must</em> be at least <code>MPI_THREAD_FUNNELED</code> if you want to call
the FFTW threads routines, so we define a global variable
<code>threads_ok</code> to record this. You should only call
<code>fftw_init_threads</code> or <code>fftw_plan_with_nthreads</code> if
<code>threads_ok</code> is true. For more information on thread safety in
MPI, see the
<a href="http://www.mpi-forum.org/docs/mpi-20-html/node162.htm">MPI and
Threads</a> section of the MPI-2 standard.
<span id="index-thread-safety-2"></span>
</p>
<p>Second, we must call <code>fftw_init_threads</code> <em>before</em>
<code>fftw_mpi_init</code>. This is critical for technical reasons having
to do with how FFTW initializes its list of algorithms.
</p>
<p>Then, if you call <code>fftw_plan_with_nthreads(N)</code>, <em>every</em> MPI
process will launch (up to) <code>N</code> threads to parallelize its transforms.
</p>
<p>For example, in the hypothetical cluster of 4-processor nodes, you
might wish to launch only a single MPI process per node, and then call
<code>fftw_plan_with_nthreads(4)</code> on each process to use all
processors in the nodes.
</p>
<p>This may or may not be faster than simply using as many MPI processes
as you have processors, however. On the one hand, using threads
within a node eliminates the need for explicit message passing within
the node. On the other hand, FFTW&rsquo;s transpose routines are not
multi-threaded, and this means that the communications that do take
place will not benefit from parallelization within the node.
Moreover, many MPI implementations already have optimizations to
exploit shared memory when it is available, so adding the
multithreaded FFTW on top of this may be superfluous.
<span id="index-transpose-4"></span>
</p>
<hr>
<div class="header">
<p>
Next: <a href="FFTW-MPI-Reference.html" accesskey="n" rel="next">FFTW MPI Reference</a>, Previous: <a href="FFTW-MPI-Performance-Tips.html" accesskey="p" rel="prev">FFTW MPI Performance Tips</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

170
fftw-3.3.10/doc/html/Complex-DFTs.html Normal file
View File

@@ -0,0 +1,170 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Complex DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Complex DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Complex DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Basic-Interface.html" rel="up" title="Basic Interface">
<link href="Planner-Flags.html" rel="next" title="Planner Flags">
<link href="Basic-Interface.html" rel="prev" title="Basic Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Complex-DFTs"></span><div class="header">
<p>
Next: <a href="Planner-Flags.html" accesskey="n" rel="next">Planner Flags</a>, Previous: <a href="Basic-Interface.html" accesskey="p" rel="prev">Basic Interface</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Complex-DFTs-1"></span><h4 class="subsection">4.3.1 Complex DFTs</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_dft_1d(int n0,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
fftw_plan fftw_plan_dft_2d(int n0, int n1,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
fftw_plan fftw_plan_dft_3d(int n0, int n1, int n2,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
fftw_plan fftw_plan_dft(int rank, const int *n,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft_005f1d-1"></span>
<span id="index-fftw_005fplan_005fdft_005f2d-1"></span>
<span id="index-fftw_005fplan_005fdft_005f3d-1"></span>
<span id="index-fftw_005fplan_005fdft-1"></span>
<p>Plan a complex input/output discrete Fourier transform (DFT) in zero or
more dimensions, returning an <code>fftw_plan</code> (see <a href="Using-Plans.html">Using Plans</a>).
</p>
<p>Once you have created a plan for a certain transform type and
parameters, then creating another plan of the same type and parameters,
but for different arrays, is fast and shares constant data with the
first plan (if it still exists).
</p>
<p>The planner returns <code>NULL</code> if the plan cannot be created. In the
standard FFTW distribution, the basic interface is guaranteed to return
a non-<code>NULL</code> plan. A plan may be <code>NULL</code>, however, if you are
using a customized FFTW configuration supporting a restricted set of
transforms.
</p>
<span id="Arguments"></span><h4 class="subsubheading">Arguments</h4>
<ul>
<li> <code>rank</code> is the rank of the transform (it should be the size of the
array <code>*n</code>), and can be any non-negative integer. (See <a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a>, for the definition of &ldquo;rank&rdquo;.) The
&lsquo;<samp>_1d</samp>&rsquo;, &lsquo;<samp>_2d</samp>&rsquo;, and &lsquo;<samp>_3d</samp>&rsquo; planners correspond to a
<code>rank</code> of <code>1</code>, <code>2</code>, and <code>3</code>, respectively. The rank
may be zero, which is equivalent to a rank-1 transform of size 1, i.e. a
copy of one number from input to output.
</li><li> <code>n0</code>, <code>n1</code>, <code>n2</code>, or <code>n[0..rank-1]</code> (as appropriate
for each routine) specify the size of the transform dimensions. They
can be any positive integer.
<ul class="no-bullet">
<li>- <span id="index-row_002dmajor-1"></span>
Multi-dimensional arrays are stored in row-major order with dimensions:
<code>n0</code> x <code>n1</code>; or <code>n0</code> x <code>n1</code> x <code>n2</code>; or
<code>n[0]</code> x <code>n[1]</code> x ... x <code>n[rank-1]</code>.
See <a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>.
</li><li>- FFTW is best at handling sizes of the form
2<sup>a</sup> 3<sup>b</sup> 5<sup>c</sup> 7<sup>d</sup>
11<sup>e</sup> 13<sup>f</sup>,
where <em>e+f</em> is either <em>0</em> or <em>1</em>, and the other exponents
are arbitrary. Other sizes are computed by means of a slow,
general-purpose algorithm (which nevertheless retains <i>O</i>(<i>n</i>&nbsp;log&nbsp;<i>n</i>)
performance even for prime sizes). It is possible to customize FFTW
for different array sizes; see <a href="Installation-and-Customization.html">Installation and Customization</a>.
Transforms whose sizes are powers of <em>2</em> are especially fast.
</li></ul>
</li><li> <code>in</code> and <code>out</code> point to the input and output arrays of the
transform, which may be the same (yielding an in-place transform).
<span id="index-in_002dplace-2"></span>
These arrays are overwritten during planning, unless
<code>FFTW_ESTIMATE</code> is used in the flags. (The arrays need not be
initialized, but they must be allocated.)
<p>If <code>in == out</code>, the transform is <em>in-place</em> and the input
array is overwritten. If <code>in != out</code>, the two arrays must
not overlap (but FFTW does not check for this condition).
</p>
</li><li> <span id="index-FFTW_005fFORWARD-2"></span>
<span id="index-FFTW_005fBACKWARD-2"></span>
<code>sign</code> is the sign of the exponent in the formula that defines the
Fourier transform. It can be <em>-1</em> (= <code>FFTW_FORWARD</code>) or
<em>+1</em> (= <code>FFTW_BACKWARD</code>).
</li><li> <span id="index-flags-2"></span>
<code>flags</code> is a bitwise OR (&lsquo;<samp>|</samp>&rsquo;) of zero or more planner flags,
as defined in <a href="Planner-Flags.html">Planner Flags</a>.
</li></ul>
<p>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).
<span id="index-normalization-5"></span>
For more information, see <a href="What-FFTW-Really-Computes.html">What FFTW Really Computes</a>.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Planner-Flags.html" accesskey="n" rel="next">Planner Flags</a>, Previous: <a href="Basic-Interface.html" accesskey="p" rel="prev">Basic Interface</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

166
fftw-3.3.10/doc/html/Complex-Multi_002dDimensional-DFTs.html Normal file
View File

@@ -0,0 +1,166 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Complex Multi-Dimensional DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Complex Multi-Dimensional DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Complex Multi-Dimensional DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Tutorial.html" rel="up" title="Tutorial">
<link href="One_002dDimensional-DFTs-of-Real-Data.html" rel="next" title="One-Dimensional DFTs of Real Data">
<link href="Complex-One_002dDimensional-DFTs.html" rel="prev" title="Complex One-Dimensional DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Complex-Multi_002dDimensional-DFTs"></span><div class="header">
<p>
Next: <a href="One_002dDimensional-DFTs-of-Real-Data.html" accesskey="n" rel="next">One-Dimensional DFTs of Real Data</a>, Previous: <a href="Complex-One_002dDimensional-DFTs.html" accesskey="p" rel="prev">Complex One-Dimensional DFTs</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Complex-Multi_002dDimensional-DFTs-1"></span><h3 class="section">2.2 Complex Multi-Dimensional DFTs</h3>
<p>Multi-dimensional transforms work much the same way as one-dimensional
transforms: you allocate arrays of <code>fftw_complex</code> (preferably
using <code>fftw_malloc</code>), create an <code>fftw_plan</code>, execute it as
many times as you want with <code>fftw_execute(plan)</code>, and clean up
with <code>fftw_destroy_plan(plan)</code> (and <code>fftw_free</code>).
</p>
<p>FFTW provides two routines for creating plans for 2d and 3d transforms,
and one routine for creating plans of arbitrary dimensionality.
The 2d and 3d routines have the following signature:
</p><div class="example">
<pre class="example">fftw_plan fftw_plan_dft_2d(int n0, int n1,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
fftw_plan fftw_plan_dft_3d(int n0, int n1, int n2,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft_005f2d"></span>
<span id="index-fftw_005fplan_005fdft_005f3d"></span>
<p>These routines create plans for <code>n0</code> by <code>n1</code> two-dimensional
(2d) transforms and <code>n0</code> by <code>n1</code> by <code>n2</code> 3d transforms,
respectively. All of these transforms operate on contiguous arrays in
the C-standard <em>row-major</em> order, so that the last dimension has the
fastest-varying index in the array. This layout is described further in
<a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>.
</p>
<p>FFTW can also compute transforms of higher dimensionality. In order to
avoid confusion between the various meanings of the the word
&ldquo;dimension&rdquo;, we use the term <em>rank</em>
<span id="index-rank"></span>
to denote the number of independent indices in an array.<a id="DOCF2" href="#FOOT2"><sup>2</sup></a> For
example, we say that a 2d transform has rank&nbsp;2, a 3d transform has
rank&nbsp;3, and so on. You can plan transforms of arbitrary rank by
means of the following function:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_plan_dft(int rank, const int *n,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft"></span>
<p>Here, <code>n</code> is a pointer to an array <code>n[rank]</code> denoting an
<code>n[0]</code> by <code>n[1]</code> by &hellip; by <code>n[rank-1]</code> transform.
Thus, for example, the call
</p><div class="example">
<pre class="example">fftw_plan_dft_2d(n0, n1, in, out, sign, flags);
</pre></div>
<p>is equivalent to the following code fragment:
</p><div class="example">
<pre class="example">int n[2];
n[0] = n0;
n[1] = n1;
fftw_plan_dft(2, n, in, out, sign, flags);
</pre></div>
<p><code>fftw_plan_dft</code> is not restricted to 2d and 3d transforms,
however, but it can plan transforms of arbitrary rank.
</p>
<p>You may have noticed that all the planner routines described so far
have overlapping functionality. For example, you can plan a 1d or 2d
transform by using <code>fftw_plan_dft</code> with a <code>rank</code> of <code>1</code>
or <code>2</code>, or even by calling <code>fftw_plan_dft_3d</code> with <code>n0</code>
and/or <code>n1</code> equal to <code>1</code> (with no loss in efficiency). This
pattern continues, and FFTW&rsquo;s planning routines in general form a
&ldquo;partial order,&rdquo; sequences of
<span id="index-partial-order"></span>
interfaces with strictly increasing generality but correspondingly
greater complexity.
</p>
<p><code>fftw_plan_dft</code> is the most general complex-DFT routine that we
describe in this tutorial, but there are also the advanced and guru interfaces,
<span id="index-advanced-interface-1"></span>
<span id="index-guru-interface-1"></span>
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 <a href="FFTW-Reference.html">FFTW Reference</a>.
</p>
<div class="footnote">
<hr>
<h4 class="footnotes-heading">Footnotes</h4>
<h5><a id="FOOT2" href="#DOCF2">(2)</a></h3>
<p>The
term &ldquo;rank&rdquo; is commonly used in the APL, FORTRAN, and Common Lisp
traditions, although it is not so common in the C&nbsp;world.</p>
</div>
<hr>
<div class="header">
<p>
Next: <a href="One_002dDimensional-DFTs-of-Real-Data.html" accesskey="n" rel="next">One-Dimensional DFTs of Real Data</a>, Previous: <a href="Complex-One_002dDimensional-DFTs.html" accesskey="p" rel="prev">Complex One-Dimensional DFTs</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

239
fftw-3.3.10/doc/html/Complex-One_002dDimensional-DFTs.html Normal file
View File

@@ -0,0 +1,239 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Complex One-Dimensional DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Complex One-Dimensional DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Complex One-Dimensional DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Tutorial.html" rel="up" title="Tutorial">
<link href="Complex-Multi_002dDimensional-DFTs.html" rel="next" title="Complex Multi-Dimensional DFTs">
<link href="Tutorial.html" rel="prev" title="Tutorial">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Complex-One_002dDimensional-DFTs"></span><div class="header">
<p>
Next: <a href="Complex-Multi_002dDimensional-DFTs.html" accesskey="n" rel="next">Complex Multi-Dimensional DFTs</a>, Previous: <a href="Tutorial.html" accesskey="p" rel="prev">Tutorial</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Complex-One_002dDimensional-DFTs-1"></span><h3 class="section">2.1 Complex One-Dimensional DFTs</h3>
<blockquote>
<p>Plan: To bother about the best method of accomplishing an accidental result.
[Ambrose Bierce, <cite>The Enlarged Devil&rsquo;s Dictionary</cite>.]
<span id="index-Devil"></span>
</p></blockquote>
<p>The basic usage of FFTW to compute a one-dimensional DFT of size
<code>N</code> is simple, and it typically looks something like this code:
</p>
<div class="example">
<pre class="example">#include &lt;fftw3.h&gt;
...
{
fftw_complex *in, *out;
fftw_plan p;
...
in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
p = fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
...
fftw_execute(p); /* <span class="roman">repeat as needed</span> */
...
fftw_destroy_plan(p);
fftw_free(in); fftw_free(out);
}
</pre></div>
<p>You must link this code with the <code>fftw3</code> library. On Unix systems,
link with <code>-lfftw3 -lm</code>.
</p>
<p>The example code first allocates the input and output arrays. You can
allocate them in any way that you like, but we recommend using
<code>fftw_malloc</code>, which behaves like
<span id="index-fftw_005fmalloc"></span>
<code>malloc</code> except that it properly aligns the array when SIMD
instructions (such as SSE and Altivec) are available (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>). [Alternatively, we provide a convenient wrapper function <code>fftw_alloc_complex(N)</code> which has the same effect.]
<span id="index-fftw_005falloc_005fcomplex"></span>
<span id="index-SIMD"></span>
</p>
<p>The data is an array of type <code>fftw_complex</code>, which is by default a
<code>double[2]</code> composed of the real (<code>in[i][0]</code>) and imaginary
(<code>in[i][1]</code>) parts of a complex number.
<span id="index-fftw_005fcomplex"></span>
</p>
<p>The next step is to create a <em>plan</em>, which is an object
<span id="index-plan-1"></span>
that contains all the data that FFTW needs to compute the FFT.
This function creates the plan:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_plan_dft_1d(int n, fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft_005f1d"></span>
<span id="index-fftw_005fplan"></span>
<p>The first argument, <code>n</code>, is the size of the transform you are
trying to compute. The size <code>n</code> can be any positive integer, but
sizes that are products of small factors are transformed most
efficiently (although prime sizes still use an <i>O</i>(<i>n</i>&nbsp;log&nbsp;<i>n</i>)
algorithm).
</p>
<p>The next two arguments are pointers to the input and output arrays of
the transform. These pointers can be equal, indicating an
<em>in-place</em> transform.
<span id="index-in_002dplace"></span>
</p>
<p>The fourth argument, <code>sign</code>, can be either <code>FFTW_FORWARD</code>
(<code>-1</code>) or <code>FFTW_BACKWARD</code> (<code>+1</code>),
<span id="index-FFTW_005fFORWARD"></span>
<span id="index-FFTW_005fBACKWARD"></span>
and indicates the direction of the transform you are interested in;
technically, it is the sign of the exponent in the transform.
</p>
<p>The <code>flags</code> argument is usually either <code>FFTW_MEASURE</code> or
<span id="index-flags"></span>
<code>FFTW_ESTIMATE</code>. <code>FFTW_MEASURE</code> instructs FFTW to run
<span id="index-FFTW_005fMEASURE"></span>
and measure the execution time of several FFTs in order to find the
best way to compute the transform of size <code>n</code>. This process takes
some time (usually a few seconds), depending on your machine and on
the size of the transform. <code>FFTW_ESTIMATE</code>, on the contrary,
does not run any computation and just builds a
<span id="index-FFTW_005fESTIMATE"></span>
reasonable plan that is probably sub-optimal. In short, if your
program performs many transforms of the same size and initialization
time is not important, use <code>FFTW_MEASURE</code>; otherwise use the
estimate.
</p>
<p><em>You must create the plan before initializing the input</em>, because
<code>FFTW_MEASURE</code> overwrites the <code>in</code>/<code>out</code> arrays.
(Technically, <code>FFTW_ESTIMATE</code> does not touch your arrays, but you
should always create plans first just to be sure.)
</p>
<p>Once the plan has been created, you can use it as many times as you
like for transforms on the specified <code>in</code>/<code>out</code> arrays,
computing the actual transforms via <code>fftw_execute(plan)</code>:
</p><div class="example">
<pre class="example">void fftw_execute(const fftw_plan plan);
</pre></div>
<span id="index-fftw_005fexecute"></span>
<p>The DFT results are stored in-order in the array <code>out</code>, with the
zero-frequency (DC) component in <code>out[0]</code>.
<span id="index-frequency"></span>
If <code>in != out</code>, the transform is <em>out-of-place</em> and the input
array <code>in</code> is not modified. Otherwise, the input array is
overwritten with the transform.
</p>
<span id="index-execute-1"></span>
<p>If you want to transform a <em>different</em> array of the same size, you
can create a new plan with <code>fftw_plan_dft_1d</code> and FFTW
automatically reuses the information from the previous plan, if
possible. Alternatively, with the &ldquo;guru&rdquo; interface you can apply a
given plan to a different array, if you are careful.
See <a href="FFTW-Reference.html">FFTW Reference</a>.
</p>
<p>When you are done with the plan, you deallocate it by calling
<code>fftw_destroy_plan(plan)</code>:
</p><div class="example">
<pre class="example">void fftw_destroy_plan(fftw_plan plan);
</pre></div>
<span id="index-fftw_005fdestroy_005fplan"></span>
<p>If you allocate an array with <code>fftw_malloc()</code> you must deallocate
it with <code>fftw_free()</code>. Do not use <code>free()</code> or, heaven
forbid, <code>delete</code>.
<span id="index-fftw_005ffree"></span>
</p>
<p>FFTW computes an <em>unnormalized</em> DFT. Thus, computing a forward
followed by a backward transform (or vice versa) results in the original
array scaled by <code>n</code>. For the definition of the DFT, see <a href="What-FFTW-Really-Computes.html">What FFTW Really Computes</a>.
<span id="index-DFT-1"></span>
<span id="index-normalization"></span>
</p>
<p>If you have a C compiler, such as <code>gcc</code>, that supports the
C99 standard, and you <code>#include &lt;complex.h&gt;</code> <em>before</em>
<code>&lt;fftw3.h&gt;</code>, then <code>fftw_complex</code> is the native
double-precision complex type and you can manipulate it with ordinary
arithmetic. Otherwise, FFTW defines its own complex type, which is
bit-compatible with the C99 complex type. See <a href="Complex-numbers.html">Complex numbers</a>.
(The C++ <code>&lt;complex&gt;</code> template class may also be usable via a
typecast.)
<span id="index-C_002b_002b"></span>
</p>
<p>To use single or long-double precision versions of FFTW, replace the
<code>fftw_</code> prefix by <code>fftwf_</code> or <code>fftwl_</code> and link with
<code>-lfftw3f</code> or <code>-lfftw3l</code>, but use the <em>same</em>
<code>&lt;fftw3.h&gt;</code> header file.
<span id="index-precision"></span>
</p>
<p>Many more flags exist besides <code>FFTW_MEASURE</code> and
<code>FFTW_ESTIMATE</code>. For example, use <code>FFTW_PATIENT</code> if you&rsquo;re
willing to wait even longer for a possibly even faster plan (see <a href="FFTW-Reference.html">FFTW Reference</a>).
<span id="index-FFTW_005fPATIENT"></span>
You can also save plans for future use, as described by <a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a>.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Complex-Multi_002dDimensional-DFTs.html" accesskey="n" rel="next">Complex Multi-Dimensional DFTs</a>, Previous: <a href="Tutorial.html" accesskey="p" rel="prev">Tutorial</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

114
fftw-3.3.10/doc/html/Complex-numbers.html Normal file
View File

@@ -0,0 +1,114 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Complex numbers (FFTW 3.3.10)</title>
<meta name="description" content="Complex numbers (FFTW 3.3.10)">
<meta name="keywords" content="Complex numbers (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Data-Types-and-Files.html" rel="up" title="Data Types and Files">
<link href="Precision.html" rel="next" title="Precision">
<link href="Data-Types-and-Files.html" rel="prev" title="Data Types and Files">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Complex-numbers"></span><div class="header">
<p>
Next: <a href="Precision.html" accesskey="n" rel="next">Precision</a>, Previous: <a href="Data-Types-and-Files.html" accesskey="p" rel="prev">Data Types and Files</a>, Up: <a href="Data-Types-and-Files.html" accesskey="u" rel="up">Data Types and Files</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Complex-numbers-1"></span><h4 class="subsection">4.1.1 Complex numbers</h4>
<p>The default FFTW interface uses <code>double</code> precision for all
floating-point numbers, and defines a <code>fftw_complex</code> type to hold
complex numbers as:
</p>
<div class="example">
<pre class="example">typedef double fftw_complex[2];
</pre></div>
<span id="index-fftw_005fcomplex-1"></span>
<p>Here, the <code>[0]</code> element holds the real part and the <code>[1]</code>
element holds the imaginary part.
</p>
<p>Alternatively, if you have a C compiler (such as <code>gcc</code>) that
supports the C99 revision of the ANSI C standard, you can use C&rsquo;s new
native complex type (which is binary-compatible with the typedef above).
In particular, if you <code>#include &lt;complex.h&gt;</code> <em>before</em>
<code>&lt;fftw3.h&gt;</code>, then <code>fftw_complex</code> is defined to be the native
complex type and you can manipulate it with ordinary arithmetic
(e.g. <code>x = y * (3+4*I)</code>, where <code>x</code> and <code>y</code> are
<code>fftw_complex</code> and <code>I</code> is the standard symbol for the
imaginary unit);
<span id="index-C99-1"></span>
</p>
<p>C++ has its own <code>complex&lt;T&gt;</code> template class, defined in the
standard <code>&lt;complex&gt;</code> header file. Reportedly, the C++ standards
committee has recently agreed to mandate that the storage format used
for this type be binary-compatible with the C99 type, i.e. an array
<code>T[2]</code> with consecutive real <code>[0]</code> and imaginary <code>[1]</code>
parts. (See report
<a href="http://www.open-std.org/jtc1/sc22/WG21/docs/papers/2002/n1388.pdf
WG21/N1388">http://www.open-std.org/jtc1/sc22/WG21/docs/papers/2002/n1388.pdf
WG21/N1388</a>.) Although not part of the official standard as of this
writing, the proposal stated that: &ldquo;This solution has been tested with
all current major implementations of the standard library and shown to
be working.&rdquo; To the extent that this is true, if you have a variable
<code>complex&lt;double&gt; *x</code>, you can pass it directly to FFTW via
<code>reinterpret_cast&lt;fftw_complex*&gt;(x)</code>.
<span id="index-C_002b_002b-3"></span>
<span id="index-portability-2"></span>
</p>
</body>
</html>

517
fftw-3.3.10/doc/html/Concept-Index.html Normal file
View File

@@ -0,0 +1,517 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Concept Index (FFTW 3.3.10)</title>
<meta name="description" content="Concept Index (FFTW 3.3.10)">
<meta name="keywords" content="Concept Index (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="#Concept-Index" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Library-Index.html" rel="next" title="Library Index">
<link href="License-and-Copyright.html" rel="prev" title="License and Copyright">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Concept-Index"></span><div class="header">
<p>
Next: <a href="Library-Index.html" accesskey="n" rel="next">Library Index</a>, Previous: <a href="License-and-Copyright.html" accesskey="p" rel="prev">License and Copyright</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="#Concept-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Concept-Index-1"></span><h2 class="chapter">13 Concept Index</h2>
<table><tr><th valign="top">Jump to: &nbsp; </th><td><a class="summary-letter" href="#Concept-Index_cp_symbol-1"><b>6</b></a>
&nbsp;
<br>
<a class="summary-letter" href="#Concept-Index_cp_letter-A"><b>A</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-B"><b>B</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-C"><b>C</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-D"><b>D</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-E"><b>E</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-F"><b>F</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-G"><b>G</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-H"><b>H</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-I"><b>I</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-K"><b>K</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-L"><b>L</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-M"><b>M</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-N"><b>N</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-O"><b>O</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-P"><b>P</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-R"><b>R</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-S"><b>S</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-T"><b>T</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-V"><b>V</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-W"><b>W</b></a>
&nbsp;
</td></tr></table>
<table class="index-cp" border="0">
<tr><td></td><th align="left">Index Entry</th><td>&nbsp;</td><th align="left"> Section</th></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_symbol-1">6</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="64_002dbit-Guru-Interface.html#index-64_002dbit-architecture">64-bit architecture</a>:</td><td>&nbsp;</td><td valign="top"><a href="64_002dbit-Guru-Interface.html">64-bit Guru Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-64_002dbit-architecture-1">64-bit architecture</a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-64_002dbit-architecture-2">64-bit architecture</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-A">A</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-advanced-interface">advanced interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html#index-advanced-interface-1">advanced interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Row_002dmajor-Format.html#index-advanced-interface-2">advanced interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Row_002dmajor-Format.html">Row-major Format</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Interface.html#index-advanced-interface-3">advanced interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Interface.html">Advanced Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-advanced-interface-4">advanced interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-advanced-interface-5">advanced interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-advanced-interface-6">advanced interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-algorithm">algorithm</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Memory-Allocation.html#index-alignment">alignment</a>:</td><td>&nbsp;</td><td valign="top"><a href="Memory-Allocation.html">Memory Allocation</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-alignment-1">alignment</a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-alignment-2">alignment</a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-alignment-3">alignment</a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-alignment-4">alignment</a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html#index-alignment-5">alignment</a>:</td><td>&nbsp;</td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-AltiVec">AltiVec</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-AVX">AVX</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-AVX2">AVX2</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-AVX512">AVX512</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-B">B</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-basic-interface">basic interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Tutorial.html#index-basic-interface-1">basic interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Tutorial.html">Tutorial</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-Interface.html#index-basic-interface-2">basic interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-Interface.html">Basic Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution.html#index-block-distribution">block distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution.html">MPI Data Distribution</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-block-distribution-1">block distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html#index-block-distribution-2">block distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html">FFTW MPI Performance Tips</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-C">C</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Fixed_002dsize-Arrays-in-C.html#index-C-multi_002ddimensional-arrays">C multi-dimensional arrays</a>:</td><td>&nbsp;</td><td valign="top"><a href="Fixed_002dsize-Arrays-in-C.html">Fixed-size Arrays in C</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-C_002b_002b">C++</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-C_002b_002b-1">C++</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Dynamic-Arrays-in-C.html#index-C_002b_002b-2">C++</a>:</td><td>&nbsp;</td><td valign="top"><a href="Dynamic-Arrays-in-C.html">Dynamic Arrays in C</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-numbers.html#index-C_002b_002b-3">C++</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-numbers.html">Complex numbers</a></td></tr>
<tr><td></td><td valign="top"><a href="Memory-Allocation.html#index-C_002b_002b-4">C++</a>:</td><td>&nbsp;</td><td valign="top"><a href="Memory-Allocation.html">Memory Allocation</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-c2r">c2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-c2r-1">c2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-c2r-2">c2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Dynamic-Arrays-in-C.html#index-C99">C99</a>:</td><td>&nbsp;</td><td valign="top"><a href="Dynamic-Arrays-in-C.html">Dynamic Arrays in C</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-numbers.html#index-C99-1">C99</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-numbers.html">Complex numbers</a></td></tr>
<tr><td></td><td valign="top"><a href="Precision.html#index-C99-2">C99</a>:</td><td>&nbsp;</td><td valign="top"><a href="Precision.html">Precision</a></td></tr>
<tr><td></td><td valign="top"><a href="Generating-your-own-code.html#index-Caml">Caml</a>:</td><td>&nbsp;</td><td valign="top"><a href="Generating-your-own-code.html">Generating your own code</a></td></tr>
<tr><td></td><td valign="top"><a href="Acknowledgments.html#index-Caml-1">Caml</a>:</td><td>&nbsp;</td><td valign="top"><a href="Acknowledgments.html">Acknowledgments</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-code-generator">code generator</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Generating-your-own-code.html#index-code-generator-1">code generator</a>:</td><td>&nbsp;</td><td valign="top"><a href="Generating-your-own-code.html">Generating your own code</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-codelet">codelet</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Customization.html#index-codelet-1">codelet</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Customization.html">Installation and Customization</a></td></tr>
<tr><td></td><td valign="top"><a href="Generating-your-own-code.html#index-codelet-2">codelet</a>:</td><td>&nbsp;</td><td valign="top"><a href="Generating-your-own-code.html">Generating your own code</a></td></tr>
<tr><td></td><td valign="top"><a href="Acknowledgments.html#index-codelet-3">codelet</a>:</td><td>&nbsp;</td><td valign="top"><a href="Acknowledgments.html">Acknowledgments</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-collective-function">collective function</a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Wisdom.html#index-collective-function-1">collective function</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html#index-collective-function-2">collective function</a>:</td><td>&nbsp;</td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html">Avoiding MPI Deadlocks</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-collective-function-3">collective function</a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-collective-function-4">collective function</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Column_002dmajor-Format.html#index-column_002dmajor">column-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Column_002dmajor-Format.html">Column-major Format</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-column_002dmajor-1">column-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran_002dinterface-routines.html#index-column_002dmajor-2">column-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran_002dinterface-routines.html">Fortran-interface routines</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-column_002dmajor-3">column-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-compiler">compiler</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Customization.html#index-compiler-1">compiler</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Customization.html">Installation and Customization</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-compiler-2">compiler</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Cycle-Counters.html#index-compiler-3">compiler</a>:</td><td>&nbsp;</td><td valign="top"><a href="Cycle-Counters.html">Cycle Counters</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-compiler-flags">compiler flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-compiler-flags-1">compiler flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Utilities.html#index-configuration-routines">configuration routines</a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Utilities.html">Wisdom Utilities</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Supported-Hardware_002fSoftware.html#index-configure"><code>configure</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Supported-Hardware_002fSoftware.html">Installation and Supported Hardware/Software</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Installation.html#index-configure-1"><code>configure</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Installation.html">FFTW MPI Installation</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-configure-2"><code>configure</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Customization.html#index-cycle-counter">cycle counter</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Customization.html">Installation and Customization</a></td></tr>
<tr><td></td><td valign="top"><a href="Cycle-Counters.html#index-cycle-counter-1">cycle counter</a>:</td><td>&nbsp;</td><td valign="top"><a href="Cycle-Counters.html">Cycle Counters</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-D">D</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html#index-data-distribution">data distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html">Distributed-memory FFTW with MPI</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-data-distribution-1">data distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution.html#index-data-distribution-2">data distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution.html">MPI Data Distribution</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html#index-data-distribution-3">data distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html#index-data-distribution-4">data distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html">Basic distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-data-distribution-5">data distribution</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-DCT">DCT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-DCT-1">DCT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-DCT-2">DCT</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html#index-deadlock">deadlock</a>:</td><td>&nbsp;</td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html">Avoiding MPI Deadlocks</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-Devil">Devil</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-DFT">DFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-DFT-1">DFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html#index-DFT-2">DFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html">The 1d Discrete Fourier Transform (DFT)</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Discrete-Hartley-Transform.html#index-DHT">DHT</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Discrete-Hartley-Transform.html">The Discrete Hartley Transform</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html#index-DHT-1">DHT</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html">1d Discrete Hartley Transforms (DHTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-discrete-cosine-transform">discrete cosine transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-discrete-cosine-transform-1">discrete cosine transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-discrete-cosine-transform-2">discrete cosine transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-discrete-Fourier-transform">discrete Fourier transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html#index-discrete-Fourier-transform-1">discrete Fourier transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html">The 1d Discrete Fourier Transform (DFT)</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Discrete-Hartley-Transform.html#index-discrete-Hartley-transform">discrete Hartley transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Discrete-Hartley-Transform.html">The Discrete Hartley Transform</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-discrete-Hartley-transform-1">discrete Hartley transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html#index-discrete-Hartley-transform-2">discrete Hartley transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html">1d Discrete Hartley Transforms (DHTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-discrete-sine-transform">discrete sine transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-discrete-sine-transform-1">discrete sine transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-discrete-sine-transform-2">discrete sine transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Complex-DFTs.html#index-dist">dist</a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Complex-DFTs.html">Advanced Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-vector-and-transform-sizes.html#index-dist-1">dist</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-DST">DST</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-DST-1">DST</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-DST-2">DST</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-E">E</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Caveats-in-Using-Wisdom.html#index-Ecclesiastes">Ecclesiastes</a>:</td><td>&nbsp;</td><td valign="top"><a href="Caveats-in-Using-Wisdom.html">Caveats in Using Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-execute">execute</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-execute-1">execute</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-execute-2">execute</a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-F">F</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-FFTW">FFTW</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Caveats-in-Using-Wisdom.html#index-fftw_002dwisdom-utility">fftw-wisdom utility</a>:</td><td>&nbsp;</td><td valign="top"><a href="Caveats-in-Using-Wisdom.html">Caveats in Using Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Utilities.html#index-fftw_002dwisdom-utility-1">fftw-wisdom utility</a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Utilities.html">Wisdom Utilities</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Utilities.html#index-fftw_002dwisdom_002dto_002dconf-utility">fftw-wisdom-to-conf utility</a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Utilities.html">Wisdom Utilities</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-flags">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-flags-1">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-flags-2">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-flags-3">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-flags-4">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Complex-DFTs.html#index-flags-5">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Complex-DFTs.html">Guru Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html#index-flags-6">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html">Guru Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002dto_002dreal-Transforms.html#index-flags-7">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002dto_002dreal-Transforms.html">Guru Real-to-real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-flags-8">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Constants-in-Fortran.html#index-flags-9">flags</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Constants-in-Fortran.html">FFTW Constants in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Column_002dmajor-Format.html#index-Fortran-interface">Fortran interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Column_002dmajor-Format.html">Column-major Format</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html#index-Fortran-interface-1">Fortran interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html">FFTW MPI Fortran Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Calling-FFTW-from-Modern-Fortran.html#index-Fortran-interface-2">Fortran interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Calling-FFTW-from-Modern-Fortran.html">Calling FFTW from Modern Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Calling-FFTW-from-Legacy-Fortran.html#index-Fortran-interface-3">Fortran interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Calling-FFTW-from-Legacy-Fortran.html">Calling FFTW from Legacy Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-Fortran_002dcallable-wrappers">Fortran-callable wrappers</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-frequency">frequency</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html#index-frequency-1">frequency</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html">The 1d Discrete Fourier Transform (DFT)</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-G">G</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-g77"><code>g77</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-guru-interface">guru interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html#index-guru-interface-1">guru interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Interface.html#index-guru-interface-2">guru interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Interface.html">Guru Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-guru-interface-3">guru interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran_002dinterface-routines.html#index-guru-interface-4">guru interface</a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran_002dinterface-routines.html">Fortran-interface routines</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-H">H</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-halfcomplex-format">halfcomplex format</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html#index-halfcomplex-format-1">halfcomplex format</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html#index-halfcomplex-format-2">halfcomplex format</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html">The 1d Real-data DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html#index-hc2r">hc2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-hc2r-1">hc2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-HDF5">HDF5</a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-Hermitian">Hermitian</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html#index-Hermitian-1">Hermitian</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html">The 1d Real-data DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-vector-and-transform-sizes.html#index-howmany-loop">howmany loop</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Complex-DFTs.html#index-howmany-parameter">howmany parameter</a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Complex-DFTs.html">Advanced Complex DFTs</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-I">I</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-IDCT">IDCT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-IDCT-1">IDCT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-IDCT-2">IDCT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-IDCT-3">IDCT</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-in_002dplace">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-in_002dplace-1">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-in_002dplace-2">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-in_002dplace-3">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html#index-in_002dplace-4">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-in_002dplace-5">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html#index-in_002dplace-6">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html">Guru Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html#index-in_002dplace-7">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html">Guru Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html#index-in_002dplace-8">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html">An improved replacement for MPI_Alltoall</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-in_002dplace-9">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-in_002dplace-10">in-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Customization.html#index-installation">installation</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Customization.html">Installation and Customization</a></td></tr>
<tr><td></td><td valign="top"><a href="Interleaved-and-split-arrays.html#index-interleaved-format">interleaved format</a>:</td><td>&nbsp;</td><td valign="top"><a href="Interleaved-and-split-arrays.html">Interleaved and split arrays</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html#index-iso_005fc_005fbinding">iso_c_binding</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html">FFTW MPI Fortran Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-iso_005fc_005fbinding-1">iso_c_binding</a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Extended-and-quadruple-precision-in-Fortran.html#index-iso_005fc_005fbinding-2">iso_c_binding</a>:</td><td>&nbsp;</td><td valign="top"><a href="Extended-and-quadruple-precision-in-Fortran.html">Extended and quadruple precision in Fortran</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-K">K</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="More-DFTs-of-Real-Data.html#index-kind-_0028r2r_0029">kind (r2r)</a>:</td><td>&nbsp;</td><td valign="top"><a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-kind-_0028r2r_0029-1">kind (r2r)</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-L">L</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-linking-on-Unix">linking on Unix</a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html#index-linking-on-Unix-1">linking on Unix</a>:</td><td>&nbsp;</td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html">Linking and Initializing MPI FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Acknowledgments.html#index-LISP">LISP</a>:</td><td>&nbsp;</td><td valign="top"><a href="Acknowledgments.html">Acknowledgments</a></td></tr>
<tr><td></td><td valign="top"><a href="Load-balancing.html#index-load-balancing">load balancing</a>:</td><td>&nbsp;</td><td valign="top"><a href="Load-balancing.html">Load balancing</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html#index-load-balancing-1">load balancing</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html">FFTW MPI Performance Tips</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-M">M</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Generating-your-own-code.html#index-monadic-programming">monadic programming</a>:</td><td>&nbsp;</td><td valign="top"><a href="Generating-your-own-code.html">Generating your own code</a></td></tr>
<tr><td></td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html#index-MPI">MPI</a>:</td><td>&nbsp;</td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html">Distributed-memory FFTW with MPI</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-MPI-1">MPI</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html#index-MPI-communicator">MPI communicator</a>:</td><td>&nbsp;</td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html">Distributed-memory FFTW with MPI</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-MPI-communicator-1">MPI communicator</a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-MPI-communicator-2">MPI communicator</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html#index-MPI-communicator-3">MPI communicator</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html">FFTW MPI Fortran Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-MPI-I_002fO">MPI I/O</a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Wisdom.html#index-MPI-I_002fO-1">MPI I/O</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Installation.html#index-mpicc"><code>mpicc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Installation.html">FFTW MPI Installation</a></td></tr>
<tr><td></td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html#index-mpicc-1"><code>mpicc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html">Linking and Initializing MPI FFTW</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-N">N</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-new_002darray-execution">new-array execution</a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-new_002darray-execution-1">new-array execution</a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-new_002darray-execution-2">new-array execution</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html#index-new_002darray-execution-3">new-array execution</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html">FFTW MPI Fortran Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-normalization">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html#index-normalization-1">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html#index-normalization-2">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-normalization-3">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Discrete-Hartley-Transform.html#index-normalization-4">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Discrete-Hartley-Transform.html">The Discrete Hartley Transform</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-normalization-5">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-normalization-6">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-normalization-7">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html#index-normalization-8">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html">The 1d Discrete Fourier Transform (DFT)</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html#index-normalization-9">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html">The 1d Real-data DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-normalization-10">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-normalization-11">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html#index-normalization-12">normalization</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html">1d Discrete Hartley Transforms (DHTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="How-Many-Threads-to-Use_003f.html#index-number-of-threads">number of threads</a>:</td><td>&nbsp;</td><td valign="top"><a href="How-Many-Threads-to-Use_003f.html">How Many Threads to Use?</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-O">O</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Supported-Hardware_002fSoftware.html#index-OpenMP">OpenMP</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Supported-Hardware_002fSoftware.html">Installation and Supported Hardware/Software</a></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-OpenMP-1">OpenMP</a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-OpenMP-2">OpenMP</a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Thread-safety.html#index-OpenMP-3">OpenMP</a>:</td><td>&nbsp;</td><td valign="top"><a href="Thread-safety.html">Thread safety</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-out_002dof_002dplace">out-of-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html#index-out_002dof_002dplace-1">out-of-place</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-P">P</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-padding">padding</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html#index-padding-1">padding</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-padding-2">padding</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html#index-padding-3">padding</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html#index-padding-4">padding</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-padding-5">padding</a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dthreaded-FFTW.html#index-parallel-transform">parallel transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html#index-parallel-transform-1">parallel transform</a>:</td><td>&nbsp;</td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html">Distributed-memory FFTW with MPI</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html#index-partial-order">partial order</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-plan">plan</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-plan-1">plan</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Introduction.html#index-planner">planner</a>:</td><td>&nbsp;</td><td valign="top"><a href="Introduction.html">Introduction</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-portability">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Caveats-in-Using-Wisdom.html#index-portability-1">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Caveats-in-Using-Wisdom.html">Caveats in Using Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-numbers.html#index-portability-2">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-numbers.html">Complex numbers</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Supported-Hardware_002fSoftware.html#index-portability-3">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Supported-Hardware_002fSoftware.html">Installation and Supported Hardware/Software</a></td></tr>
<tr><td></td><td valign="top"><a href="Calling-FFTW-from-Modern-Fortran.html#index-portability-4">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Calling-FFTW-from-Modern-Fortran.html">Calling FFTW from Modern Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-portability-5">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran_002dinterface-routines.html#index-portability-6">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran_002dinterface-routines.html">Fortran-interface routines</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran_002dinterface-routines.html#index-portability-7">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran_002dinterface-routines.html">Fortran-interface routines</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-of-Fortran_003f.html#index-portability-8">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-of-Fortran_003f.html">Wisdom of Fortran?</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-and-Customization.html#index-portability-9">portability</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-and-Customization.html">Installation and Customization</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-precision">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-precision-1">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-precision-2">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Precision.html#index-precision-3">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Precision.html">Precision</a></td></tr>
<tr><td></td><td valign="top"><a href="Memory-Allocation.html#index-precision-4">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Memory-Allocation.html">Memory Allocation</a></td></tr>
<tr><td></td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html#index-precision-5">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html">Linking and Initializing MPI FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Files-and-Data-Types.html#index-precision-6">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Files-and-Data-Types.html">MPI Files and Data Types</a></td></tr>
<tr><td></td><td valign="top"><a href="Extended-and-quadruple-precision-in-Fortran.html#index-precision-7">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Extended-and-quadruple-precision-in-Fortran.html">Extended and quadruple precision in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-precision-8">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-precision-9">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-precision-10">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-precision-11">precision</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-R">R</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-r2c">r2c</a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html#index-r2c-1">r2c</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-r2c-2">r2c</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-Transforms.html#index-r2c-3">r2c</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-Transforms.html">Multi-dimensional Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-r2c-4">r2c</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html#index-r2c_002fc2r-multi_002ddimensional-array-format">r2c/c2r multi-dimensional array format</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html#index-r2c_002fc2r-multi_002ddimensional-array-format-1">r2c/c2r multi-dimensional array format</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-r2c_002fc2r-multi_002ddimensional-array-format-2">r2c/c2r multi-dimensional array format</a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-r2c_002fc2r-multi_002ddimensional-array-format-3">r2c/c2r multi-dimensional array format</a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html#index-r2hc">r2hc</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="More-DFTs-of-Real-Data.html#index-r2r">r2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-r2r-1">r2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html#index-r2r-2">r2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html">The 1d Real-data DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html#index-r2r-3">r2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html">Other Multi-dimensional Real-data MPI Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-r2r-4">r2r</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html#index-rank">rank</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-real_002deven-DFT">real-even DFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-real_002deven-DFT-1">real-even DFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-real_002dodd-DFT">real-odd DFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-real_002dodd-DFT-1">real-odd DFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-REDFT">REDFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-REDFT-1">REDFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Generating-your-own-code.html#index-REDFT-2">REDFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Generating-your-own-code.html">Generating your own code</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-RODFT">RODFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-RODFT-1">RODFT</a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="Row_002dmajor-Format.html#index-row_002dmajor">row-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Row_002dmajor-Format.html">Row-major Format</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-row_002dmajor-1">row-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-row_002dmajor-2">row-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-vector-and-transform-sizes.html#index-row_002dmajor-3">row-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-row_002dmajor-4">row-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html#index-row_002dmajor-5">row-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-row_002dmajor-6">row-major</a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-S">S</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-saving-plans-to-disk">saving plans to disk</a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom.html#index-saving-plans-to-disk-1">saving plans to disk</a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom.html">Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Wisdom.html#index-saving-plans-to-disk-2">saving plans to disk</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Accessing-the-wisdom-API-from-Fortran.html#index-saving-plans-to-disk-3">saving plans to disk</a>:</td><td>&nbsp;</td><td valign="top"><a href="Accessing-the-wisdom-API-from-Fortran.html">Accessing the wisdom API from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dthreaded-FFTW.html#index-shared_002dmemory">shared-memory</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-SIMD">SIMD</a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-SIMD-1">SIMD</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-SIMD-2">SIMD</a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Interleaved-and-split-arrays.html#index-split-format">split format</a>:</td><td>&nbsp;</td><td valign="top"><a href="Interleaved-and-split-arrays.html">Interleaved and split arrays</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-SSE">SSE</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-SSE2">SSE2</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Row_002dmajor-Format.html#index-stride">stride</a>:</td><td>&nbsp;</td><td valign="top"><a href="Row_002dmajor-Format.html">Row-major Format</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Complex-DFTs.html#index-stride-1">stride</a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Complex-DFTs.html">Advanced Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-vector-and-transform-sizes.html#index-stride-2">stride</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-stride-3">stride</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-T">T</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-thread-safety">thread safety</a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Thread-safety.html#index-thread-safety-1">thread safety</a>:</td><td>&nbsp;</td><td valign="top"><a href="Thread-safety.html">Thread safety</a></td></tr>
<tr><td></td><td valign="top"><a href="Combining-MPI-and-Threads.html#index-thread-safety-2">thread safety</a>:</td><td>&nbsp;</td><td valign="top"><a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dthreaded-FFTW.html#index-threads">threads</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Thread-safety.html#index-threads-1">threads</a>:</td><td>&nbsp;</td><td valign="top"><a href="Thread-safety.html">Thread safety</a></td></tr>
<tr><td></td><td valign="top"><a href="Combining-MPI-and-Threads.html#index-threads-2">threads</a>:</td><td>&nbsp;</td><td valign="top"><a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a></td></tr>
<tr><td></td><td valign="top"><a href="Installation-on-Unix.html#index-threads-3">threads</a>:</td><td>&nbsp;</td><td valign="top"><a href="Installation-on-Unix.html">Installation on Unix</a></td></tr>
<tr><td></td><td valign="top"><a href="Transposed-distributions.html#index-transpose">transpose</a>:</td><td>&nbsp;</td><td valign="top"><a href="Transposed-distributions.html">Transposed distributions</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html#index-transpose-1">transpose</a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Transposes.html#index-transpose-2">transpose</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Transposes.html">FFTW MPI Transposes</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html#index-transpose-3">transpose</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html">FFTW MPI Performance Tips</a></td></tr>
<tr><td></td><td valign="top"><a href="Combining-MPI-and-Threads.html#index-transpose-4">transpose</a>:</td><td>&nbsp;</td><td valign="top"><a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-transpose-5">transpose</a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-V">V</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Interface.html#index-vector">vector</a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Interface.html">Guru Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-VSX">VSX</a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Concept-Index_cp_letter-W">W</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-wisdom">wisdom</a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom.html#index-wisdom-1">wisdom</a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom.html">Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Wisdom.html#index-wisdom-2">wisdom</a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Accessing-the-wisdom-API-from-Fortran.html#index-wisdom-3">wisdom</a>:</td><td>&nbsp;</td><td valign="top"><a href="Accessing-the-wisdom-API-from-Fortran.html">Accessing the wisdom API from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Caveats-in-Using-Wisdom.html#index-wisdom_002c-problems-with">wisdom, problems with</a>:</td><td>&nbsp;</td><td valign="top"><a href="Caveats-in-Using-Wisdom.html">Caveats in Using Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Caveats-in-Using-Wisdom.html#index-wisdom_002c-system_002dwide">wisdom, system-wide</a>:</td><td>&nbsp;</td><td valign="top"><a href="Caveats-in-Using-Wisdom.html">Caveats in Using Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Import.html#index-wisdom_002c-system_002dwide-1">wisdom, system-wide</a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Import.html">Wisdom Import</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
</table>
<table><tr><th valign="top">Jump to: &nbsp; </th><td><a class="summary-letter" href="#Concept-Index_cp_symbol-1"><b>6</b></a>
&nbsp;
<br>
<a class="summary-letter" href="#Concept-Index_cp_letter-A"><b>A</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-B"><b>B</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-C"><b>C</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-D"><b>D</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-E"><b>E</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-F"><b>F</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-G"><b>G</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-H"><b>H</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-I"><b>I</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-K"><b>K</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-L"><b>L</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-M"><b>M</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-N"><b>N</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-O"><b>O</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-P"><b>P</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-R"><b>R</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-S"><b>S</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-T"><b>T</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-V"><b>V</b></a>
&nbsp;
<a class="summary-letter" href="#Concept-Index_cp_letter-W"><b>W</b></a>
&nbsp;
</td></tr></table>
<hr>
<div class="header">
<p>
Next: <a href="Library-Index.html" accesskey="n" rel="next">Library Index</a>, Previous: <a href="License-and-Copyright.html" accesskey="p" rel="prev">License and Copyright</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="#Concept-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

109
fftw-3.3.10/doc/html/Cycle-Counters.html Normal file
View File

@@ -0,0 +1,109 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Cycle Counters (FFTW 3.3.10)</title>
<meta name="description" content="Cycle Counters (FFTW 3.3.10)">
<meta name="keywords" content="Cycle Counters (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Installation-and-Customization.html" rel="up" title="Installation and Customization">
<link href="Generating-your-own-code.html" rel="next" title="Generating your own code">
<link href="Installation-on-non_002dUnix-systems.html" rel="prev" title="Installation on non-Unix systems">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Cycle-Counters"></span><div class="header">
<p>
Next: <a href="Generating-your-own-code.html" accesskey="n" rel="next">Generating your own code</a>, Previous: <a href="Installation-on-non_002dUnix-systems.html" accesskey="p" rel="prev">Installation on non-Unix systems</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Cycle-Counters-1"></span><h3 class="section">10.3 Cycle Counters</h3>
<span id="index-cycle-counter-1"></span>
<p>FFTW&rsquo;s planner actually executes and times different possible FFT
algorithms in order to pick the fastest plan for a given <em>n</em>. In
order to do this in as short a time as possible, however, the timer must
have a very high resolution, and to accomplish this we employ the
hardware <em>cycle counters</em> that are available on most CPUs.
Currently, FFTW supports the cycle counters on x86, PowerPC/POWER, Alpha,
UltraSPARC (SPARC v9), IA64, PA-RISC, and MIPS processors.
</p>
<span id="index-compiler-3"></span>
<p>Access to the cycle counters, unfortunately, is a compiler and/or
operating-system dependent task, often requiring inline assembly
language, and it may be that your compiler is not supported. If you are
<em>not</em> supported, FFTW will by default fall back on its estimator
(effectively using <code>FFTW_ESTIMATE</code> for all plans).
<span id="index-FFTW_005fESTIMATE-3"></span>
</p>
<p>You can add support by editing the file <code>kernel/cycle.h</code>; normally,
this will involve adapting one of the examples already present in order
to use the inline-assembler syntax for your C compiler, and will only
require a couple of lines of code. Anyone adding support for a new
system to <code>cycle.h</code> is encouraged to email us at <a href="mailto:fftw@fftw.org">fftw@fftw.org</a>.
</p>
<p>If a cycle counter is not available on your system (e.g. some embedded
processor), and you don&rsquo;t want to use estimated plans, as a last resort
you can use the <code>--with-slow-timer</code> option to <code>configure</code> (on
Unix) or <code>#define WITH_SLOW_TIMER</code> in <code>config.h</code> (elsewhere).
This will use the much lower-resolution <code>gettimeofday</code> function, or even
<code>clock</code> if the former is unavailable, and planning will be
extremely slow.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Generating-your-own-code.html" accesskey="n" rel="next">Generating your own code</a>, Previous: <a href="Installation-on-non_002dUnix-systems.html" accesskey="p" rel="prev">Installation on non-Unix systems</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

91
fftw-3.3.10/doc/html/Data-Types-and-Files.html Normal file
View File

@@ -0,0 +1,91 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Data Types and Files (FFTW 3.3.10)</title>
<meta name="description" content="Data Types and Files (FFTW 3.3.10)">
<meta name="keywords" content="Data Types and Files (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-Reference.html" rel="up" title="FFTW Reference">
<link href="Complex-numbers.html" rel="next" title="Complex numbers">
<link href="FFTW-Reference.html" rel="prev" title="FFTW Reference">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Data-Types-and-Files"></span><div class="header">
<p>
Next: <a href="Using-Plans.html" accesskey="n" rel="next">Using Plans</a>, Previous: <a href="FFTW-Reference.html" accesskey="p" rel="prev">FFTW Reference</a>, Up: <a href="FFTW-Reference.html" accesskey="u" rel="up">FFTW Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Data-Types-and-Files-1"></span><h3 class="section">4.1 Data Types and Files</h3>
<p>All programs using FFTW should include its header file:
</p>
<div class="example">
<pre class="example">#include &lt;fftw3.h&gt;
</pre></div>
<p>You must also link to the FFTW library. On Unix, this
means adding <code>-lfftw3 -lm</code> at the <em>end</em> of the link command.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Complex-numbers.html" accesskey="1">Complex numbers</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Precision.html" accesskey="2">Precision</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Memory-Allocation.html" accesskey="3">Memory Allocation</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

99
fftw-3.3.10/doc/html/Defining-an-FFTW-module.html Normal file
View File

@@ -0,0 +1,99 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Defining an FFTW module (FFTW 3.3.10)</title>
<meta name="description" content="Defining an FFTW module (FFTW 3.3.10)">
<meta name="keywords" content="Defining an FFTW module (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="up" title="Calling FFTW from Modern Fortran">
<link href="Calling-FFTW-from-Legacy-Fortran.html" rel="next" title="Calling FFTW from Legacy Fortran">
<link href="Wisdom-Generic-Export_002fImport-from-Fortran.html" rel="prev" title="Wisdom Generic Export/Import from Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Defining-an-FFTW-module"></span><div class="header">
<p>
Previous: <a href="Accessing-the-wisdom-API-from-Fortran.html" accesskey="p" rel="prev">Accessing the wisdom API from Fortran</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Defining-an-FFTW-module-1"></span><h3 class="section">7.7 Defining an FFTW module</h3>
<p>Rather than using the <code>include</code> statement to include the
<code>fftw3.f03</code> interface file in any subroutine where you want to
use FFTW, you might prefer to define an FFTW Fortran module. FFTW
does not install itself as a module, primarily because
<code>fftw3.f03</code> can be shared between different Fortran compilers while
modules (in general) cannot. However, it is trivial to define your
own FFTW module if you want. Just create a file containing:
</p>
<div class="example">
<pre class="example"> module FFTW3
use, intrinsic :: iso_c_binding
include 'fftw3.f03'
end module
</pre></div>
<p>Compile this file into a module as usual for your compiler (e.g. with
<code>gfortran -c</code> you will get a file <code>fftw3.mod</code>). Now,
instead of <code>include 'fftw3.f03'</code>, whenever you want to use FFTW
routines you can just do:
</p>
<div class="example">
<pre class="example"> use FFTW3
</pre></div>
<p>as usual for Fortran modules. (You still need to link to the FFTW
library, of course.)
</p>
</body>
</html>

150
fftw-3.3.10/doc/html/Distributed_002dmemory-FFTW-with-MPI.html Normal file
View File

@@ -0,0 +1,150 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Distributed-memory FFTW with MPI (FFTW 3.3.10)</title>
<meta name="description" content="Distributed-memory FFTW with MPI (FFTW 3.3.10)">
<meta name="keywords" content="Distributed-memory FFTW with MPI (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="FFTW-MPI-Installation.html" rel="next" title="FFTW MPI Installation">
<link href="Thread-safety.html" rel="prev" title="Thread safety">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Distributed_002dmemory-FFTW-with-MPI"></span><div class="header">
<p>
Next: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="n" rel="next">Calling FFTW from Modern Fortran</a>, Previous: <a href="Multi_002dthreaded-FFTW.html" accesskey="p" rel="prev">Multi-threaded FFTW</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Distributed_002dmemory-FFTW-with-MPI-1"></span><h2 class="chapter">6 Distributed-memory FFTW with MPI</h2>
<span id="index-MPI"></span>
<span id="index-parallel-transform-1"></span>
<p>In this chapter we document the parallel FFTW routines for parallel
systems supporting the MPI message-passing interface. Unlike the
shared-memory threads described in the previous chapter, MPI allows
you to use <em>distributed-memory</em> parallelism, where each CPU has
its own separate memory, and which can scale up to clusters of many
thousands of processors. This capability comes at a price, however:
each process only stores a <em>portion</em> of the data to be
transformed, which means that the data structures and
programming-interface are quite different from the serial or threads
versions of FFTW.
<span id="index-data-distribution"></span>
</p>
<p>Distributed-memory parallelism is especially useful when you are
transforming arrays so large that they do not fit into the memory of a
single processor. The storage per-process required by FFTW&rsquo;s MPI
routines is proportional to the total array size divided by the number
of processes. Conversely, distributed-memory parallelism can easily
pose an unacceptably high communications overhead for small problems;
the threshold problem size for which parallelism becomes advantageous
will depend on the precise problem you are interested in, your
hardware, and your MPI implementation.
</p>
<p>A note on terminology: in MPI, you divide the data among a set of
&ldquo;processes&rdquo; which each run in their own memory address space.
Generally, each process runs on a different physical processor, but
this is not required. A set of processes in MPI is described by an
opaque data structure called a &ldquo;communicator,&rdquo; the most common of
which is the predefined communicator <code>MPI_COMM_WORLD</code> which
refers to <em>all</em> processes. For more information on these and
other concepts common to all MPI programs, we refer the reader to the
documentation at <a href="http://www.mcs.anl.gov/research/projects/mpi/">the MPI home
page</a>.
<span id="index-MPI-communicator"></span>
<span id="index-MPI_005fCOMM_005fWORLD"></span>
</p>
<p>We assume in this chapter that the reader is familiar with the usage
of the serial (uniprocessor) FFTW, and focus only on the concepts new
to the MPI interface.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="FFTW-MPI-Installation.html" accesskey="1">FFTW MPI Installation</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Linking-and-Initializing-MPI-FFTW.html" accesskey="2">Linking and Initializing MPI FFTW</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="2d-MPI-example.html" accesskey="3">2d MPI example</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="MPI-Data-Distribution.html" accesskey="4">MPI Data Distribution</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html" accesskey="5">Multi-dimensional MPI DFTs of Real Data</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html" accesskey="6">Other Multi-dimensional Real-data MPI Transforms</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-MPI-Transposes.html" accesskey="7">FFTW MPI Transposes</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-MPI-Wisdom.html" accesskey="8">FFTW MPI Wisdom</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Avoiding-MPI-Deadlocks.html" accesskey="9">Avoiding MPI Deadlocks</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-MPI-Performance-Tips.html">FFTW MPI Performance Tips</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-MPI-Reference.html">FFTW MPI Reference</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="FFTW-MPI-Fortran-Interface.html">FFTW MPI Fortran Interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<hr>
<div class="header">
<p>
Next: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="n" rel="next">Calling FFTW from Modern Fortran</a>, Previous: <a href="Multi_002dthreaded-FFTW.html" accesskey="p" rel="prev">Multi-threaded FFTW</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

108
fftw-3.3.10/doc/html/Dynamic-Arrays-in-C.html Normal file
View File

@@ -0,0 +1,108 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Dynamic Arrays in C (FFTW 3.3.10)</title>
<meta name="description" content="Dynamic Arrays in C (FFTW 3.3.10)">
<meta name="keywords" content="Dynamic Arrays in C (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Multi_002ddimensional-Array-Format.html" rel="up" title="Multi-dimensional Array Format">
<link href="Dynamic-Arrays-in-C_002dThe-Wrong-Way.html" rel="next" title="Dynamic Arrays in C-The Wrong Way">
<link href="Fixed_002dsize-Arrays-in-C.html" rel="prev" title="Fixed-size Arrays in C">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Dynamic-Arrays-in-C"></span><div class="header">
<p>
Next: <a href="Dynamic-Arrays-in-C_002dThe-Wrong-Way.html" accesskey="n" rel="next">Dynamic Arrays in C-The Wrong Way</a>, Previous: <a href="Fixed_002dsize-Arrays-in-C.html" accesskey="p" rel="prev">Fixed-size Arrays in C</a>, Up: <a href="Multi_002ddimensional-Array-Format.html" accesskey="u" rel="up">Multi-dimensional Array Format</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Dynamic-Arrays-in-C-1"></span><h4 class="subsection">3.2.4 Dynamic Arrays in C</h4>
<p>We recommend allocating most arrays dynamically, with
<code>fftw_malloc</code>. This isn&rsquo;t too hard to do, although it is not as
straightforward for multi-dimensional arrays as it is for
one-dimensional arrays.
</p>
<p>Creating the array is simple: using a dynamic-allocation routine like
<code>fftw_malloc</code>, allocate an array big enough to store N
<code>fftw_complex</code> values (for a complex DFT), where N is the product
of the sizes of the array dimensions (i.e. the total number of complex
values in the array). For example, here is code to allocate a
5&nbsp;&times;&nbsp;12&nbsp;&times;&nbsp;27
rank-3 array:
<span id="index-fftw_005fmalloc-2"></span>
</p>
<div class="example">
<pre class="example">fftw_complex *an_array;
an_array = (fftw_complex*) fftw_malloc(5*12*27 * sizeof(fftw_complex));
</pre></div>
<p>Accessing the array elements, however, is more tricky&mdash;you can&rsquo;t
simply use multiple applications of the &lsquo;<samp>[]</samp>&rsquo; operator like you
could for fixed-size arrays. Instead, you have to explicitly compute
the offset into the array using the formula given earlier for
row-major arrays. For example, to reference the <em>(i,j,k)</em>-th
element of the array allocated above, you would use the expression
<code>an_array[k + 27 * (j + 12 * i)]</code>.
</p>
<p>This pain can be alleviated somewhat by defining appropriate macros,
or, in C++, creating a class and overloading the &lsquo;<samp>()</samp>&rsquo; operator.
The recent C99 standard provides a way to reinterpret the dynamic
array as a &ldquo;variable-length&rdquo; multi-dimensional array amenable to
&lsquo;<samp>[]</samp>&rsquo;, but this feature is not yet widely supported by compilers.
<span id="index-C99"></span>
<span id="index-C_002b_002b-2"></span>
</p>
</body>
</html>

108
fftw-3.3.10/doc/html/Dynamic-Arrays-in-C_002dThe-Wrong-Way.html Normal file
View File

@@ -0,0 +1,108 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Dynamic Arrays in C-The Wrong Way (FFTW 3.3.10)</title>
<meta name="description" content="Dynamic Arrays in C-The Wrong Way (FFTW 3.3.10)">
<meta name="keywords" content="Dynamic Arrays in C-The Wrong Way (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Multi_002ddimensional-Array-Format.html" rel="up" title="Multi-dimensional Array Format">
<link href="Words-of-Wisdom_002dSaving-Plans.html" rel="next" title="Words of Wisdom-Saving Plans">
<link href="Dynamic-Arrays-in-C.html" rel="prev" title="Dynamic Arrays in C">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Dynamic-Arrays-in-C_002dThe-Wrong-Way"></span><div class="header">
<p>
Previous: <a href="Dynamic-Arrays-in-C.html" accesskey="p" rel="prev">Dynamic Arrays in C</a>, Up: <a href="Multi_002ddimensional-Array-Format.html" accesskey="u" rel="up">Multi-dimensional Array Format</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Dynamic-Arrays-in-C_002d_002d_002dThe-Wrong-Way"></span><h4 class="subsection">3.2.5 Dynamic Arrays in C&mdash;The Wrong Way</h4>
<p>A different method for allocating multi-dimensional arrays in C is
often suggested that is incompatible with FFTW: <em>using it will
cause FFTW to die a painful death</em>. We discuss the technique here,
however, because it is so commonly known and used. This method is to
create arrays of pointers of arrays of pointers of &hellip;etcetera.
For example, the analogue in this method to the example above is:
</p>
<div class="example">
<pre class="example">int i,j;
fftw_complex ***a_bad_array; /* <span class="roman">another way to make a 5x12x27 array</span> */
a_bad_array = (fftw_complex ***) malloc(5 * sizeof(fftw_complex **));
for (i = 0; i &lt; 5; ++i) {
a_bad_array[i] =
(fftw_complex **) malloc(12 * sizeof(fftw_complex *));
for (j = 0; j &lt; 12; ++j)
a_bad_array[i][j] =
(fftw_complex *) malloc(27 * sizeof(fftw_complex));
}
</pre></div>
<p>As you can see, this sort of array is inconvenient to allocate (and
deallocate). On the other hand, it has the advantage that the
<em>(i,j,k)</em>-th element can be referenced simply by
<code>a_bad_array[i][j][k]</code>.
</p>
<p>If you like this technique and want to maximize convenience in accessing
the array, but still want to pass the array to FFTW, you can use a
hybrid method. Allocate the array as one contiguous block, but also
declare an array of arrays of pointers that point to appropriate places
in the block. That sort of trick is beyond the scope of this
documentation; for more information on multi-dimensional arrays in C,
see the <code>comp.lang.c</code>
<a href="http://c-faq.com/aryptr/dynmuldimary.html">FAQ</a>.
</p>
</body>
</html>

102
fftw-3.3.10/doc/html/Extended-and-quadruple-precision-in-Fortran.html Normal file
View File

@@ -0,0 +1,102 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Extended and quadruple precision in Fortran (FFTW 3.3.10)</title>
<meta name="description" content="Extended and quadruple precision in Fortran (FFTW 3.3.10)">
<meta name="keywords" content="Extended and quadruple precision in Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Overview-of-Fortran-interface.html" rel="up" title="Overview of Fortran interface">
<link href="Reversing-array-dimensions.html" rel="next" title="Reversing array dimensions">
<link href="Overview-of-Fortran-interface.html" rel="prev" title="Overview of Fortran interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Extended-and-quadruple-precision-in-Fortran"></span><div class="header">
<p>
Previous: <a href="Overview-of-Fortran-interface.html" accesskey="p" rel="prev">Overview of Fortran interface</a>, Up: <a href="Overview-of-Fortran-interface.html" accesskey="u" rel="up">Overview of Fortran interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Extended-and-quadruple-precision-in-Fortran-1"></span><h4 class="subsection">7.1.1 Extended and quadruple precision in Fortran</h4>
<span id="index-precision-7"></span>
<p>If FFTW is compiled in <code>long double</code> (extended) precision
(see <a href="Installation-and-Customization.html">Installation and Customization</a>), you may be able to call the
resulting <code>fftwl_</code> routines (see <a href="Precision.html">Precision</a>) from Fortran if
your compiler supports the <code>C_LONG_DOUBLE_COMPLEX</code> type code.
</p>
<p>Because some Fortran compilers do not support
<code>C_LONG_DOUBLE_COMPLEX</code>, the <code>fftwl_</code> declarations are
segregated into a separate interface file <code>fftw3l.f03</code>, which you
should include <em>in addition</em> to <code>fftw3.f03</code> (which declares
precision-independent &lsquo;<samp>FFTW_</samp>&rsquo; constants):
</p>
<span id="index-iso_005fc_005fbinding-2"></span>
<div class="example">
<pre class="example"> use, intrinsic :: iso_c_binding
include 'fftw3.f03'
include 'fftw3l.f03'
</pre></div>
<p>We also support using the nonstandard <code>__float128</code>
quadruple-precision type provided by recent versions of <code>gcc</code> on
32- and 64-bit x86 hardware (see <a href="Installation-and-Customization.html">Installation and Customization</a>),
using the corresponding <code>real(16)</code> and <code>complex(16)</code> types
supported by <code>gfortran</code>. The quadruple-precision &lsquo;<samp>fftwq_</samp>&rsquo;
functions (see <a href="Precision.html">Precision</a>) are declared in a <code>fftw3q.f03</code>
interface file, which should be included in addition to
<code>fftw3.f03</code>, as above. You should also link with
<code>-lfftw3q -lquadmath -lm</code> as in C.
</p>
</body>
</html>

93
fftw-3.3.10/doc/html/FFTW-Constants-in-Fortran.html Normal file
View File

@@ -0,0 +1,93 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW Constants in Fortran (FFTW 3.3.10)</title>
<meta name="description" content="FFTW Constants in Fortran (FFTW 3.3.10)">
<meta name="keywords" content="FFTW Constants in Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Legacy-Fortran.html" rel="up" title="Calling FFTW from Legacy Fortran">
<link href="FFTW-Execution-in-Fortran.html" rel="next" title="FFTW Execution in Fortran">
<link href="Fortran_002dinterface-routines.html" rel="prev" title="Fortran-interface routines">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-Constants-in-Fortran"></span><div class="header">
<p>
Next: <a href="FFTW-Execution-in-Fortran.html" accesskey="n" rel="next">FFTW Execution in Fortran</a>, Previous: <a href="Fortran_002dinterface-routines.html" accesskey="p" rel="prev">Fortran-interface routines</a>, Up: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="u" rel="up">Calling FFTW from Legacy Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-Constants-in-Fortran-1"></span><h3 class="section">8.2 FFTW Constants in Fortran</h3>
<p>When creating plans in FFTW, a number of constants are used to specify
options, such as <code>FFTW_MEASURE</code> or <code>FFTW_ESTIMATE</code>. The
same constants must be used with the wrapper routines, but of course the
C header files where the constants are defined can&rsquo;t be incorporated
directly into Fortran code.
</p>
<p>Instead, we have placed Fortran equivalents of the FFTW constant
definitions in the file <code>fftw3.f</code>, which can be found in the same
directory as <code>fftw3.h</code>. If your Fortran compiler supports a
preprocessor of some sort, you should be able to <code>include</code> or
<code>#include</code> this file; otherwise, you can paste it directly into
your code.
</p>
<span id="index-flags-9"></span>
<p>In C, you combine different flags (like <code>FFTW_PRESERVE_INPUT</code> and
<code>FFTW_MEASURE</code>) using the &lsquo;<samp><code>|</code></samp>&rsquo; operator; in Fortran
you should just use &lsquo;<samp><code>+</code></samp>&rsquo;. (Take care not to add in the
same flag more than once, though. Alternatively, you can use the
<code>ior</code> intrinsic function standardized in Fortran 95.)
</p>
</body>
</html>

134
fftw-3.3.10/doc/html/FFTW-Execution-in-Fortran.html Normal file
View File

@@ -0,0 +1,134 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW Execution in Fortran (FFTW 3.3.10)</title>
<meta name="description" content="FFTW Execution in Fortran (FFTW 3.3.10)">
<meta name="keywords" content="FFTW Execution in Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Legacy-Fortran.html" rel="up" title="Calling FFTW from Legacy Fortran">
<link href="Fortran-Examples.html" rel="next" title="Fortran Examples">
<link href="FFTW-Constants-in-Fortran.html" rel="prev" title="FFTW Constants in Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-Execution-in-Fortran"></span><div class="header">
<p>
Next: <a href="Fortran-Examples.html" accesskey="n" rel="next">Fortran Examples</a>, Previous: <a href="FFTW-Constants-in-Fortran.html" accesskey="p" rel="prev">FFTW Constants in Fortran</a>, Up: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="u" rel="up">Calling FFTW from Legacy Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-Execution-in-Fortran-1"></span><h3 class="section">8.3 FFTW Execution in Fortran</h3>
<p>In C, in order to use a plan, one normally calls <code>fftw_execute</code>,
which executes the plan to perform the transform on the input/output
arrays passed when the plan was created (see <a href="Using-Plans.html">Using Plans</a>). The
corresponding subroutine call in legacy Fortran is:
</p><div class="example">
<pre class="example"> call dfftw_execute(plan)
</pre></div>
<span id="index-dfftw_005fexecute"></span>
<p>However, we have had reports that this causes problems with some
recent optimizing Fortran compilers. The problem is, because the
input/output arrays are not passed as explicit arguments to
<code>dfftw_execute</code>, the semantics of Fortran (unlike C) allow the
compiler to assume that the input/output arrays are not changed by
<code>dfftw_execute</code>. As a consequence, certain compilers end up
optimizing out or repositioning the call to <code>dfftw_execute</code>,
assuming incorrectly that it does nothing.
</p>
<p>There are various workarounds to this, but the safest and simplest
thing is to not use <code>dfftw_execute</code> in Fortran. Instead, use the
functions described in <a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a>, which take
the input/output arrays as explicit arguments. For example, if the
plan is for a complex-data DFT and was created for the arrays
<code>in</code> and <code>out</code>, you would do:
</p><div class="example">
<pre class="example"> call dfftw_execute_dft(plan, in, out)
</pre></div>
<span id="index-dfftw_005fexecute_005fdft"></span>
<p>There are a few things to be careful of, however:
</p>
<ul>
<li> You must use the correct type of execute function, matching the way
the plan was created. Complex DFT plans should use
<code>dfftw_execute_dft</code>, Real-input (r2c) DFT plans should use use
<code>dfftw_execute_dft_r2c</code>, and real-output (c2r) DFT plans should
use <code>dfftw_execute_dft_c2r</code>. The various r2r plans should use
<code>dfftw_execute_r2r</code>.
</li><li> You should normally pass the same input/output arrays that were used when
creating the plan. This is always safe.
</li><li> <em>If</em> you pass <em>different</em> input/output arrays compared to
those used when creating the plan, you must abide by all the
restrictions of the new-array execute functions (see <a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a>). The most difficult of these, in Fortran, is the
requirement that the new arrays have the same alignment as the
original arrays, because there seems to be no way in legacy Fortran to obtain
guaranteed-aligned arrays (analogous to <code>fftw_malloc</code> in C). You
can, of course, use the <code>FFTW_UNALIGNED</code> flag when creating the
plan, in which case the plan does not depend on the alignment, but
this may sacrifice substantial performance on architectures (like x86)
with SIMD instructions (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>).
<span id="index-FFTW_005fUNALIGNED-3"></span>
</li></ul>
<hr>
<div class="header">
<p>
Next: <a href="Fortran-Examples.html" accesskey="n" rel="next">Fortran Examples</a>, Previous: <a href="FFTW-Constants-in-Fortran.html" accesskey="p" rel="prev">FFTW Constants in Fortran</a>, Up: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="u" rel="up">Calling FFTW from Legacy Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

173
fftw-3.3.10/doc/html/FFTW-Fortran-type-reference.html Normal file
View File

@@ -0,0 +1,173 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW Fortran type reference (FFTW 3.3.10)</title>
<meta name="description" content="FFTW Fortran type reference (FFTW 3.3.10)">
<meta name="keywords" content="FFTW Fortran type reference (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="up" title="Calling FFTW from Modern Fortran">
<link href="Plan-execution-in-Fortran.html" rel="next" title="Plan execution in Fortran">
<link href="Reversing-array-dimensions.html" rel="prev" title="Reversing array dimensions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-Fortran-type-reference"></span><div class="header">
<p>
Next: <a href="Plan-execution-in-Fortran.html" accesskey="n" rel="next">Plan execution in Fortran</a>, Previous: <a href="Reversing-array-dimensions.html" accesskey="p" rel="prev">Reversing array dimensions</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-Fortran-type-reference-1"></span><h3 class="section">7.3 FFTW Fortran type reference</h3>
<p>The following are the most important type correspondences between the
C interface and Fortran:
</p>
<ul>
<li> <span id="index-fftw_005fplan-2"></span>
Plans (<code>fftw_plan</code> and variants) are <code>type(C_PTR)</code> (i.e. an
opaque pointer).
</li><li> <span id="index-fftw_005fcomplex-3"></span>
<span id="index-precision-8"></span>
<span id="index-C_005fDOUBLE-1"></span>
<span id="index-C_005fFLOAT"></span>
<span id="index-C_005fLONG_005fDOUBLE"></span>
<span id="index-C_005fDOUBLE_005fCOMPLEX-1"></span>
<span id="index-C_005fFLOAT_005fCOMPLEX"></span>
<span id="index-C_005fLONG_005fDOUBLE_005fCOMPLEX"></span>
The C floating-point types <code>double</code>, <code>float</code>, and <code>long
double</code> correspond to <code>real(C_DOUBLE)</code>, <code>real(C_FLOAT)</code>, and
<code>real(C_LONG_DOUBLE)</code>, respectively. The C complex types
<code>fftw_complex</code>, <code>fftwf_complex</code>, and <code>fftwl_complex</code>
correspond in Fortran to <code>complex(C_DOUBLE_COMPLEX)</code>,
<code>complex(C_FLOAT_COMPLEX)</code>, and
<code>complex(C_LONG_DOUBLE_COMPLEX)</code>, respectively.
Just as in C
(see <a href="Precision.html">Precision</a>), the FFTW subroutines and types are prefixed with
&lsquo;<samp>fftw_</samp>&rsquo;, <code>fftwf_</code>, and <code>fftwl_</code> for the different precisions, and link to different libraries (<code>-lfftw3</code>, <code>-lfftw3f</code>, and <code>-lfftw3l</code> on Unix), but use the <em>same</em> include file <code>fftw3.f03</code> and the <em>same</em> constants (all of which begin with &lsquo;<samp>FFTW_</samp>&rsquo;). The exception is <code>long double</code> precision, for which you should <em>also</em> include <code>fftw3l.f03</code> (see <a href="Extended-and-quadruple-precision-in-Fortran.html">Extended and quadruple precision in Fortran</a>).
</li><li> <span id="index-ptrdiff_005ft-2"></span>
<span id="index-C_005fINT-1"></span>
<span id="index-C_005fINTPTR_005fT"></span>
<span id="index-C_005fSIZE_005fT"></span>
<span id="index-fftw_005fmalloc-7"></span>
The C integer types <code>int</code> and <code>unsigned</code> (used for planner
flags) become <code>integer(C_INT)</code>. The C integer type <code>ptrdiff_t</code> (e.g. in the <a href="64_002dbit-Guru-Interface.html">64-bit Guru Interface</a>) becomes <code>integer(C_INTPTR_T)</code>, and <code>size_t</code> (in <code>fftw_malloc</code> etc.) becomes <code>integer(C_SIZE_T)</code>.
</li><li> <span id="index-fftw_005fr2r_005fkind-2"></span>
<span id="index-C_005fFFTW_005fR2R_005fKIND"></span>
The <code>fftw_r2r_kind</code> type (see <a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a>)
becomes <code>integer(C_FFTW_R2R_KIND)</code>. The various constant values
of the C enumerated type (<code>FFTW_R2HC</code> etc.) become simply integer
constants of the same names in Fortran.
</li><li> <span id="index-FFTW_005fDESTROY_005fINPUT-2"></span>
<span id="index-in_002dplace-10"></span>
<span id="index-fftw_005fflops-2"></span>
Numeric array pointer arguments (e.g. <code>double *</code>)
become <code>dimension(*), intent(out)</code> arrays of the same type, or
<code>dimension(*), intent(in)</code> if they are pointers to constant data
(e.g. <code>const int *</code>). There are a few exceptions where numeric
pointers refer to scalar outputs (e.g. for <code>fftw_flops</code>), in which
case they are <code>intent(out)</code> scalar arguments in Fortran too.
For the new-array execute functions (see <a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a>),
the input arrays are declared <code>dimension(*), intent(inout)</code>, since
they can be modified in the case of in-place or <code>FFTW_DESTROY_INPUT</code>
transforms.
</li><li> <span id="index-fftw_005falloc_005freal-4"></span>
<span id="index-c_005ff_005fpointer-1"></span>
Pointer <em>return</em> values (e.g <code>double *</code>) become
<code>type(C_PTR)</code>. (If they are pointers to arrays, as for
<code>fftw_alloc_real</code>, you can convert them back to Fortran array
pointers with the standard intrinsic function <code>c_f_pointer</code>.)
</li><li> <span id="index-guru-interface-3"></span>
<span id="index-fftw_005fiodim-1"></span>
<span id="index-fftw_005fiodim64-1"></span>
<span id="index-64_002dbit-architecture-2"></span>
The <code>fftw_iodim</code> type in the guru interface (see <a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a>) becomes <code>type(fftw_iodim)</code> in Fortran, a
derived data type (the Fortran analogue of C&rsquo;s <code>struct</code>) with
three <code>integer(C_INT)</code> components: <code>n</code>, <code>is</code>, and
<code>os</code>, with the same meanings as in C. The <code>fftw_iodim64</code> type in the 64-bit guru interface (see <a href="64_002dbit-Guru-Interface.html">64-bit Guru Interface</a>) is the same, except that its components are of type <code>integer(C_INTPTR_T)</code>.
</li><li> <span id="index-C_005fFUNPTR"></span>
Using the wisdom import/export functions from Fortran is a bit tricky,
and is discussed in <a href="Accessing-the-wisdom-API-from-Fortran.html">Accessing the wisdom API from Fortran</a>. In
brief, the <code>FILE *</code> arguments map to <code>type(C_PTR)</code>, <code>const char *</code> to <code>character(C_CHAR), dimension(*), intent(in)</code> (null-terminated!), and the generic read-char/write-char functions map to <code>type(C_FUNPTR)</code>.
</li></ul>
<span id="index-portability-5"></span>
<p>You may be wondering if you need to search-and-replace
<code>real(kind(0.0d0))</code> (or whatever your favorite Fortran spelling
of &ldquo;double precision&rdquo; is) with <code>real(C_DOUBLE)</code> everywhere in
your program, and similarly for <code>complex</code> and <code>integer</code>
types. The answer is no; you can still use your existing types. As
long as these types match their C counterparts, things should work
without a hitch. The worst that can happen, e.g. in the (unlikely)
event of a system where <code>real(kind(0.0d0))</code> is different from
<code>real(C_DOUBLE)</code>, is that the compiler will give you a
type-mismatch error. That is, if you don&rsquo;t use the
<code>iso_c_binding</code> kinds you need to accept at least the theoretical
possibility of having to change your code in response to compiler
errors on some future machine, but you don&rsquo;t need to worry about
silently compiling incorrect code that yields runtime errors.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Plan-execution-in-Fortran.html" accesskey="n" rel="next">Plan execution in Fortran</a>, Previous: <a href="Reversing-array-dimensions.html" accesskey="p" rel="prev">Reversing array dimensions</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

226
fftw-3.3.10/doc/html/FFTW-MPI-Fortran-Interface.html Normal file
View File

@@ -0,0 +1,226 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW MPI Fortran Interface (FFTW 3.3.10)</title>
<meta name="description" content="FFTW MPI Fortran Interface (FFTW 3.3.10)">
<meta name="keywords" content="FFTW MPI Fortran Interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="next" title="Calling FFTW from Modern Fortran">
<link href="MPI-Wisdom-Communication.html" rel="prev" title="MPI Wisdom Communication">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-MPI-Fortran-Interface"></span><div class="header">
<p>
Previous: <a href="FFTW-MPI-Reference.html" accesskey="p" rel="prev">FFTW MPI Reference</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-MPI-Fortran-Interface-1"></span><h3 class="section">6.13 FFTW MPI Fortran Interface</h3>
<span id="index-Fortran-interface-1"></span>
<span id="index-iso_005fc_005fbinding"></span>
<p>The FFTW MPI interface is callable from modern Fortran compilers
supporting the Fortran 2003 <code>iso_c_binding</code> standard for calling
C functions. As described in <a href="Calling-FFTW-from-Modern-Fortran.html">Calling FFTW from Modern Fortran</a>,
this means that you can directly call FFTW&rsquo;s C interface from Fortran
with only minor changes in syntax. There are, however, a few things
specific to the MPI interface to keep in mind:
</p>
<ul>
<li> Instead of including <code>fftw3.f03</code> as in <a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a>, you should <code>include 'fftw3-mpi.f03'</code> (after
<code>use, intrinsic :: iso_c_binding</code> as before). The
<code>fftw3-mpi.f03</code> file includes <code>fftw3.f03</code>, so you should
<em>not</em> <code>include</code> them both yourself. (You will also want to
include the MPI header file, usually via <code>include 'mpif.h'</code> or
similar, although though this is not needed by <code>fftw3-mpi.f03</code>
<i>per se</i>.) (To use the &lsquo;<samp>fftwl_</samp>&rsquo; <code>long double</code> extended-precision routines in supporting compilers, you should include <code>fftw3f-mpi.f03</code> in <em>addition</em> to <code>fftw3-mpi.f03</code>. See <a href="Extended-and-quadruple-precision-in-Fortran.html">Extended and quadruple precision in Fortran</a>.)
</li><li> Because of the different storage conventions between C and Fortran,
you reverse the order of your array dimensions when passing them to
FFTW (see <a href="Reversing-array-dimensions.html">Reversing array dimensions</a>). This is merely a
difference in notation and incurs no performance overhead. However,
it means that, whereas in C the <em>first</em> dimension is distributed,
in Fortran the <em>last</em> dimension of your array is distributed.
</li><li> <span id="index-MPI-communicator-3"></span>
In Fortran, communicators are stored as <code>integer</code> types; there is
no <code>MPI_Comm</code> type, nor is there any way to access a C
<code>MPI_Comm</code>. Fortunately, this is taken care of for you by the
FFTW Fortran interface: whenever the C interface expects an
<code>MPI_Comm</code> type, you should pass the Fortran communicator as an
<code>integer</code>.<a id="DOCF8" href="#FOOT8"><sup>8</sup></a>
</li><li> Because you need to call the &lsquo;<samp>local_size</samp>&rsquo; function to find out
how much space to allocate, and this may be <em>larger</em> than the
local portion of the array (see <a href="MPI-Data-Distribution.html">MPI Data Distribution</a>), you should
<em>always</em> allocate your arrays dynamically using FFTW&rsquo;s allocation
routines as described in <a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a>.
(Coincidentally, this also provides the best performance by
guaranteeding proper data alignment.)
</li><li> Because all sizes in the MPI FFTW interface are declared as
<code>ptrdiff_t</code> in C, you should use <code>integer(C_INTPTR_T)</code> in
Fortran (see <a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a>).
</li><li> <span id="index-fftw_005fexecute_005fdft-1"></span>
<span id="index-fftw_005fmpi_005fexecute_005fdft-1"></span>
<span id="index-new_002darray-execution-3"></span>
In Fortran, because of the language semantics, we generally recommend
using the new-array execute functions for all plans, even in the
common case where you are executing the plan on the same arrays for
which the plan was created (see <a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a>).
However, note that in the MPI interface these functions are changed:
<code>fftw_execute_dft</code> becomes <code>fftw_mpi_execute_dft</code>,
etcetera. See <a href="Using-MPI-Plans.html">Using MPI Plans</a>.
</li></ul>
<p>For example, here is a Fortran code snippet to perform a distributed
L&nbsp;&times;&nbsp;M
complex DFT in-place. (This assumes you have already
initialized MPI with <code>MPI_init</code> and have also performed
<code>call fftw_mpi_init</code>.)
</p>
<div class="example">
<pre class="example"> use, intrinsic :: iso_c_binding
include 'fftw3-mpi.f03'
integer(C_INTPTR_T), parameter :: L = ...
integer(C_INTPTR_T), parameter :: M = ...
type(C_PTR) :: plan, cdata
complex(C_DOUBLE_COMPLEX), pointer :: data(:,:)
integer(C_INTPTR_T) :: i, j, alloc_local, local_M, local_j_offset
! <span class="roman">get local data size and allocate (note dimension reversal)</span>
alloc_local = fftw_mpi_local_size_2d(M, L, MPI_COMM_WORLD, &amp;
local_M, local_j_offset)
cdata = fftw_alloc_complex(alloc_local)
call c_f_pointer(cdata, data, [L,local_M])
! <span class="roman">create MPI plan for in-place forward DFT (note dimension reversal)</span>
plan = fftw_mpi_plan_dft_2d(M, L, data, data, MPI_COMM_WORLD, &amp;
FFTW_FORWARD, FFTW_MEASURE)
! <span class="roman">initialize data to some function</span> my_function(i,j)
do j = 1, local_M
do i = 1, L
data(i, j) = my_function(i, j + local_j_offset)
end do
end do
! <span class="roman">compute transform (as many times as desired)</span>
call fftw_mpi_execute_dft(plan, data, data)
call fftw_destroy_plan(plan)
call fftw_free(cdata)
</pre></div>
<p>Note that when we called <code>fftw_mpi_local_size_2d</code> and
<code>fftw_mpi_plan_dft_2d</code> with the dimensions in reversed order,
since a L&nbsp;&times;&nbsp;M
Fortran array is viewed by FFTW in C as a
M&nbsp;&times;&nbsp;L
array. This means that the array was distributed over
the <code>M</code> dimension, the local portion of which is a
L&nbsp;&times;&nbsp;local_M
array in Fortran. (You must <em>not</em> use an
<code>allocate</code> statement to allocate an L&nbsp;&times;&nbsp;local_M
array,
however; you must allocate <code>alloc_local</code> complex numbers, which
may be greater than <code>L * local_M</code>, in order to reserve space for
intermediate steps of the transform.) Finally, we mention that
because C&rsquo;s array indices are zero-based, the <code>local_j_offset</code>
argument can conveniently be interpreted as an offset in the 1-based
<code>j</code> index (rather than as a starting index as in C).
</p>
<p>If instead you had used the <code>ior(FFTW_MEASURE,
FFTW_MPI_TRANSPOSED_OUT)</code> flag, the output of the transform would be a
transposed M&nbsp;&times;&nbsp;local_L
array, associated with the <em>same</em>
<code>cdata</code> allocation (since the transform is in-place), and which
you could declare with:
</p>
<div class="example">
<pre class="example"> complex(C_DOUBLE_COMPLEX), pointer :: tdata(:,:)
...
call c_f_pointer(cdata, tdata, [M,local_L])
</pre></div>
<p>where <code>local_L</code> would have been obtained by changing the
<code>fftw_mpi_local_size_2d</code> call to:
</p>
<div class="example">
<pre class="example"> alloc_local = fftw_mpi_local_size_2d_transposed(M, L, MPI_COMM_WORLD, &amp;
local_M, local_j_offset, local_L, local_i_offset)
</pre></div>
<div class="footnote">
<hr>
<h4 class="footnotes-heading">Footnotes</h4>
<h5><a id="FOOT8" href="#DOCF8">(8)</a></h3>
<p>Technically, this is because you aren&rsquo;t
actually calling the C functions directly. You are calling wrapper
functions that translate the communicator with <code>MPI_Comm_f2c</code>
before calling the ordinary C interface. This is all done
transparently, however, since the <code>fftw3-mpi.f03</code> interface file
renames the wrappers so that they are called in Fortran with the same
names as the C interface functions.</p>
</div>
<hr>
<div class="header">
<p>
Previous: <a href="FFTW-MPI-Reference.html" accesskey="p" rel="prev">FFTW MPI Reference</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

106
fftw-3.3.10/doc/html/FFTW-MPI-Installation.html Normal file
View File

@@ -0,0 +1,106 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW MPI Installation (FFTW 3.3.10)</title>
<meta name="description" content="FFTW MPI Installation (FFTW 3.3.10)">
<meta name="keywords" content="FFTW MPI Installation (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="Linking-and-Initializing-MPI-FFTW.html" rel="next" title="Linking and Initializing MPI FFTW">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="prev" title="Distributed-memory FFTW with MPI">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-MPI-Installation"></span><div class="header">
<p>
Next: <a href="Linking-and-Initializing-MPI-FFTW.html" accesskey="n" rel="next">Linking and Initializing MPI FFTW</a>, Previous: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="p" rel="prev">Distributed-memory FFTW with MPI</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-MPI-Installation-1"></span><h3 class="section">6.1 FFTW MPI Installation</h3>
<p>All of the FFTW MPI code is located in the <code>mpi</code> subdirectory of
the FFTW package. On Unix systems, the FFTW MPI libraries and header
files are automatically configured, compiled, and installed along with
the uniprocessor FFTW libraries simply by including
<code>--enable-mpi</code> in the flags to the <code>configure</code> script
(see <a href="Installation-on-Unix.html">Installation on Unix</a>).
<span id="index-configure-1"></span>
</p>
<p>Any implementation of the MPI standard, version 1 or later, should
work with FFTW. The <code>configure</code> script will attempt to
automatically detect how to compile and link code using your MPI
implementation. In some cases, especially if you have multiple
different MPI implementations installed or have an unusual MPI
software package, you may need to provide this information explicitly.
</p>
<p>Most commonly, one compiles MPI code by invoking a special compiler
command, typically <code>mpicc</code> for C code. The <code>configure</code>
script knows the most common names for this command, but you can
specify the MPI compilation command explicitly by setting the
<code>MPICC</code> variable, as in &lsquo;<samp>./configure MPICC=mpicc ...</samp>&rsquo;.
<span id="index-mpicc"></span>
</p>
<p>If, instead of a special compiler command, you need to link a certain
library, you can specify the link command via the <code>MPILIBS</code>
variable, as in &lsquo;<samp>./configure MPILIBS=-lmpi ...</samp>&rsquo;. Note that if
your MPI library is installed in a non-standard location (one the
compiler does not know about by default), you may also have to specify
the location of the library and header files via <code>LDFLAGS</code> and
<code>CPPFLAGS</code> variables, respectively, as in &lsquo;<samp>./configure
LDFLAGS=-L/path/to/mpi/libs CPPFLAGS=-I/path/to/mpi/include ...</samp>&rsquo;.
</p>
</body>
</html>

104
fftw-3.3.10/doc/html/FFTW-MPI-Performance-Tips.html Normal file
View File

@@ -0,0 +1,104 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW MPI Performance Tips (FFTW 3.3.10)</title>
<meta name="description" content="FFTW MPI Performance Tips (FFTW 3.3.10)">
<meta name="keywords" content="FFTW MPI Performance Tips (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="Combining-MPI-and-Threads.html" rel="next" title="Combining MPI and Threads">
<link href="Avoiding-MPI-Deadlocks.html" rel="prev" title="Avoiding MPI Deadlocks">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-MPI-Performance-Tips"></span><div class="header">
<p>
Next: <a href="Combining-MPI-and-Threads.html" accesskey="n" rel="next">Combining MPI and Threads</a>, Previous: <a href="Avoiding-MPI-Deadlocks.html" accesskey="p" rel="prev">Avoiding MPI Deadlocks</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-MPI-Performance-Tips-1"></span><h3 class="section">6.10 FFTW MPI Performance Tips</h3>
<p>In this section, we collect a few tips on getting the best performance
out of FFTW&rsquo;s MPI transforms.
</p>
<p>First, because of the 1d block distribution, FFTW&rsquo;s parallelization is
currently limited by the size of the first dimension.
(Multidimensional block distributions may be supported by a future
version.) More generally, you should ideally arrange the dimensions so
that FFTW can divide them equally among the processes. See <a href="Load-balancing.html">Load balancing</a>.
<span id="index-block-distribution-2"></span>
<span id="index-load-balancing-1"></span>
</p>
<p>Second, if it is not too inconvenient, you should consider working
with transposed output for multidimensional plans, as this saves a
considerable amount of communications. See <a href="Transposed-distributions.html">Transposed distributions</a>.
<span id="index-transpose-3"></span>
</p>
<p>Third, the fastest choices are generally either an in-place transform
or an out-of-place transform with the <code>FFTW_DESTROY_INPUT</code> flag
(which allows the input array to be used as scratch space). In-place
is especially beneficial if the amount of data per process is large.
<span id="index-FFTW_005fDESTROY_005fINPUT-1"></span>
</p>
<p>Fourth, if you have multiple arrays to transform at once, rather than
calling FFTW&rsquo;s MPI transforms several times it usually seems to be
faster to interleave the data and use the advanced interface. (This
groups the communications together instead of requiring separate
messages for each transform.)
</p>
</body>
</html>

92
fftw-3.3.10/doc/html/FFTW-MPI-Reference.html Normal file
View File

@@ -0,0 +1,92 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW MPI Reference (FFTW 3.3.10)</title>
<meta name="description" content="FFTW MPI Reference (FFTW 3.3.10)">
<meta name="keywords" content="FFTW MPI Reference (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="MPI-Files-and-Data-Types.html" rel="next" title="MPI Files and Data Types">
<link href="Combining-MPI-and-Threads.html" rel="prev" title="Combining MPI and Threads">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-MPI-Reference"></span><div class="header">
<p>
Next: <a href="FFTW-MPI-Fortran-Interface.html" accesskey="n" rel="next">FFTW MPI Fortran Interface</a>, Previous: <a href="Combining-MPI-and-Threads.html" accesskey="p" rel="prev">Combining MPI and Threads</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-MPI-Reference-1"></span><h3 class="section">6.12 FFTW MPI Reference</h3>
<p>This chapter provides a complete reference to all FFTW MPI functions,
datatypes, and constants. See also <a href="FFTW-Reference.html">FFTW Reference</a> for information
on functions and types in common with the serial interface.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="MPI-Files-and-Data-Types.html" accesskey="1">MPI Files and Data Types</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="MPI-Initialization.html" accesskey="2">MPI Initialization</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Using-MPI-Plans.html" accesskey="3">Using MPI Plans</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="MPI-Data-Distribution-Functions.html" accesskey="4">MPI Data Distribution Functions</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="MPI-Plan-Creation.html" accesskey="5">MPI Plan Creation</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="MPI-Wisdom-Communication.html" accesskey="6">MPI Wisdom Communication</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

92
fftw-3.3.10/doc/html/FFTW-MPI-Transposes.html Normal file
View File

@@ -0,0 +1,92 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW MPI Transposes (FFTW 3.3.10)</title>
<meta name="description" content="FFTW MPI Transposes (FFTW 3.3.10)">
<meta name="keywords" content="FFTW MPI Transposes (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="Basic-distributed_002dtranspose-interface.html" rel="next" title="Basic distributed-transpose interface">
<link href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html" rel="prev" title="Other Multi-dimensional Real-data MPI Transforms">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-MPI-Transposes"></span><div class="header">
<p>
Next: <a href="FFTW-MPI-Wisdom.html" accesskey="n" rel="next">FFTW MPI Wisdom</a>, Previous: <a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html" accesskey="p" rel="prev">Other Multi-dimensional Real-data MPI Transforms</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-MPI-Transposes-1"></span><h3 class="section">6.7 FFTW MPI Transposes</h3>
<span id="index-transpose-2"></span>
<p>The FFTW&rsquo;s MPI Fourier transforms rely on one or more <em>global
transposition</em> step for their communications. For example, the
multidimensional transforms work by transforming along some
dimensions, then transposing to make the first dimension local and
transforming that, then transposing back. Because global
transposition of a block-distributed matrix has many other potential
uses besides FFTs, FFTW&rsquo;s transpose routines can be called directly,
as documented in this section.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Basic-distributed_002dtranspose-interface.html" accesskey="1">Basic distributed-transpose interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Advanced-distributed_002dtranspose-interface.html" accesskey="2">Advanced distributed-transpose interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="An-improved-replacement-for-MPI_005fAlltoall.html" accesskey="3">An improved replacement for MPI_Alltoall</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

171
fftw-3.3.10/doc/html/FFTW-MPI-Wisdom.html Normal file
View File

@@ -0,0 +1,171 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW MPI Wisdom (FFTW 3.3.10)</title>
<meta name="description" content="FFTW MPI Wisdom (FFTW 3.3.10)">
<meta name="keywords" content="FFTW MPI Wisdom (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="Avoiding-MPI-Deadlocks.html" rel="next" title="Avoiding MPI Deadlocks">
<link href="An-improved-replacement-for-MPI_005fAlltoall.html" rel="prev" title="An improved replacement for MPI_Alltoall">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-MPI-Wisdom"></span><div class="header">
<p>
Next: <a href="Avoiding-MPI-Deadlocks.html" accesskey="n" rel="next">Avoiding MPI Deadlocks</a>, Previous: <a href="FFTW-MPI-Transposes.html" accesskey="p" rel="prev">FFTW MPI Transposes</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-MPI-Wisdom-1"></span><h3 class="section">6.8 FFTW MPI Wisdom</h3>
<span id="index-wisdom-2"></span>
<span id="index-saving-plans-to-disk-2"></span>
<p>FFTW&rsquo;s &ldquo;wisdom&rdquo; facility (see <a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a>) can
be used to save MPI plans as well as to save uniprocessor plans.
However, for MPI there are several unavoidable complications.
</p>
<span id="index-MPI-I_002fO-1"></span>
<p>First, the MPI standard does not guarantee that every process can
perform file I/O (at least, not using C stdio routines)&mdash;in general,
we may only assume that process 0 is capable of I/O.<a id="DOCF7" href="#FOOT7"><sup>7</sup></a> So, if we
want to export the wisdom from a single process to a file, we must
first export the wisdom to a string, then send it to process 0, then
write it to a file.
</p>
<p>Second, in principle we may want to have separate wisdom for every
process, since in general the processes may run on different hardware
even for a single MPI program. However, in practice FFTW&rsquo;s MPI code
is designed for the case of homogeneous hardware (see <a href="Load-balancing.html">Load balancing</a>), and in this case it is convenient to use the same wisdom
for every process. Thus, we need a mechanism to synchronize the wisdom.
</p>
<p>To address both of these problems, FFTW provides the following two
functions:
</p>
<div class="example">
<pre class="example">void fftw_mpi_broadcast_wisdom(MPI_Comm comm);
void fftw_mpi_gather_wisdom(MPI_Comm comm);
</pre></div>
<span id="index-fftw_005fmpi_005fgather_005fwisdom"></span>
<span id="index-fftw_005fmpi_005fbroadcast_005fwisdom"></span>
<p>Given a communicator <code>comm</code>, <code>fftw_mpi_broadcast_wisdom</code>
will broadcast the wisdom from process 0 to all other processes.
Conversely, <code>fftw_mpi_gather_wisdom</code> will collect wisdom from all
processes onto process 0. (If the plans created for the same problem
by different processes are not the same, <code>fftw_mpi_gather_wisdom</code>
will arbitrarily choose one of the plans.) Both of these functions
may result in suboptimal plans for different processes if the
processes are running on non-identical hardware. Both of these
functions are <em>collective</em> calls, which means that they must be
executed by all processes in the communicator.
<span id="index-collective-function-1"></span>
</p>
<p>So, for example, a typical code snippet to import wisdom from a file
and use it on all processes would be:
</p>
<div class="example">
<pre class="example">{
int rank;
fftw_mpi_init();
MPI_Comm_rank(MPI_COMM_WORLD, &amp;rank);
if (rank == 0) fftw_import_wisdom_from_filename(&quot;mywisdom&quot;);
fftw_mpi_broadcast_wisdom(MPI_COMM_WORLD);
}
</pre></div>
<p>(Note that we must call <code>fftw_mpi_init</code> before importing any
wisdom that might contain MPI plans.) Similarly, a typical code
snippet to export wisdom from all processes to a file is:
<span id="index-fftw_005fmpi_005finit-2"></span>
</p>
<div class="example">
<pre class="example">{
int rank;
fftw_mpi_gather_wisdom(MPI_COMM_WORLD);
MPI_Comm_rank(MPI_COMM_WORLD, &amp;rank);
if (rank == 0) fftw_export_wisdom_to_filename(&quot;mywisdom&quot;);
}
</pre></div>
<div class="footnote">
<hr>
<h4 class="footnotes-heading">Footnotes</h4>
<h5><a id="FOOT7" href="#DOCF7">(7)</a></h3>
<p>In fact,
even this assumption is not technically guaranteed by the standard,
although it seems to be universal in actual MPI implementations and is
widely assumed by MPI-using software. Technically, you need to query
the <code>MPI_IO</code> attribute of <code>MPI_COMM_WORLD</code> with
<code>MPI_Attr_get</code>. If this attribute is <code>MPI_PROC_NULL</code>, no
I/O is possible. If it is <code>MPI_ANY_SOURCE</code>, any process can
perform I/O. Otherwise, it is the rank of a process that can perform
I/O ... but since it is not guaranteed to yield the <em>same</em> rank
on all processes, you have to do an <code>MPI_Allreduce</code> of some kind
if you want all processes to agree about which is going to do I/O.
And even then, the standard only guarantees that this process can
perform output, but not input. See e.g. <cite>Parallel Programming
with MPI</cite> by P. S. Pacheco, section 8.1.3. Needless to say, in our
experience virtually no MPI programmers worry about this.</p>
</div>
<hr>
<div class="header">
<p>
Next: <a href="Avoiding-MPI-Deadlocks.html" accesskey="n" rel="next">Avoiding MPI Deadlocks</a>, Previous: <a href="FFTW-MPI-Transposes.html" accesskey="p" rel="prev">FFTW MPI Transposes</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

96
fftw-3.3.10/doc/html/FFTW-Reference.html Normal file
View File

@@ -0,0 +1,96 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>FFTW Reference (FFTW 3.3.10)</title>
<meta name="description" content="FFTW Reference (FFTW 3.3.10)">
<meta name="keywords" content="FFTW Reference (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Data-Types-and-Files.html" rel="next" title="Data Types and Files">
<link href="Caveats-in-Using-Wisdom.html" rel="prev" title="Caveats in Using Wisdom">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="FFTW-Reference"></span><div class="header">
<p>
Next: <a href="Multi_002dthreaded-FFTW.html" accesskey="n" rel="next">Multi-threaded FFTW</a>, Previous: <a href="Other-Important-Topics.html" accesskey="p" rel="prev">Other Important Topics</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="FFTW-Reference-1"></span><h2 class="chapter">4 FFTW Reference</h2>
<p>This chapter provides a complete reference for all sequential (i.e.,
one-processor) FFTW functions. Parallel transforms are described in
later chapters.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Data-Types-and-Files.html" accesskey="1">Data Types and Files</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Using-Plans.html" accesskey="2">Using Plans</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Basic-Interface.html" accesskey="3">Basic Interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Advanced-Interface.html" accesskey="4">Advanced Interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Guru-Interface.html" accesskey="5">Guru Interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="New_002darray-Execute-Functions.html" accesskey="6">New-array Execute Functions</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Wisdom.html" accesskey="7">Wisdom</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="What-FFTW-Really-Computes.html" accesskey="8">What FFTW Really Computes</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

104
fftw-3.3.10/doc/html/Fixed_002dsize-Arrays-in-C.html Normal file
View File

@@ -0,0 +1,104 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Fixed-size Arrays in C (FFTW 3.3.10)</title>
<meta name="description" content="Fixed-size Arrays in C (FFTW 3.3.10)">
<meta name="keywords" content="Fixed-size Arrays in C (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Multi_002ddimensional-Array-Format.html" rel="up" title="Multi-dimensional Array Format">
<link href="Dynamic-Arrays-in-C.html" rel="next" title="Dynamic Arrays in C">
<link href="Column_002dmajor-Format.html" rel="prev" title="Column-major Format">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Fixed_002dsize-Arrays-in-C"></span><div class="header">
<p>
Next: <a href="Dynamic-Arrays-in-C.html" accesskey="n" rel="next">Dynamic Arrays in C</a>, Previous: <a href="Column_002dmajor-Format.html" accesskey="p" rel="prev">Column-major Format</a>, Up: <a href="Multi_002ddimensional-Array-Format.html" accesskey="u" rel="up">Multi-dimensional Array Format</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Fixed_002dsize-Arrays-in-C-1"></span><h4 class="subsection">3.2.3 Fixed-size Arrays in C</h4>
<span id="index-C-multi_002ddimensional-arrays"></span>
<p>A multi-dimensional array whose size is declared at compile time in C
is <em>already</em> in row-major order. You don&rsquo;t have to do anything
special to transform it. For example:
</p>
<div class="example">
<pre class="example">{
fftw_complex data[N0][N1][N2];
fftw_plan plan;
...
plan = fftw_plan_dft_3d(N0, N1, N2, &amp;data[0][0][0], &amp;data[0][0][0],
FFTW_FORWARD, FFTW_ESTIMATE);
...
}
</pre></div>
<p>This will plan a 3d in-place transform of size <code>N0 x N1 x N2</code>.
Notice how we took the address of the zero-th element to pass to the
planner (we could also have used a typecast).
</p>
<p>However, we tend to <em>discourage</em> users from declaring their
arrays in this way, for two reasons. First, this allocates the array
on the stack (&ldquo;automatic&rdquo; storage), which has a very limited size on
most operating systems (declaring an array with more than a few
thousand elements will often cause a crash). (You can get around this
limitation on many systems by declaring the array as
<code>static</code> and/or global, but that has its own drawbacks.)
Second, it may not optimally align the array for use with a SIMD
FFTW (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>). Instead, we recommend
using <code>fftw_malloc</code>, as described below.
</p>
</body>
</html>

82
fftw-3.3.10/doc/html/Forgetting-Wisdom.html Normal file
View File

@@ -0,0 +1,82 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Forgetting Wisdom (FFTW 3.3.10)</title>
<meta name="description" content="Forgetting Wisdom (FFTW 3.3.10)">
<meta name="keywords" content="Forgetting Wisdom (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Wisdom.html" rel="up" title="Wisdom">
<link href="Wisdom-Utilities.html" rel="next" title="Wisdom Utilities">
<link href="Wisdom-Import.html" rel="prev" title="Wisdom Import">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Forgetting-Wisdom"></span><div class="header">
<p>
Next: <a href="Wisdom-Utilities.html" accesskey="n" rel="next">Wisdom Utilities</a>, Previous: <a href="Wisdom-Import.html" accesskey="p" rel="prev">Wisdom Import</a>, Up: <a href="Wisdom.html" accesskey="u" rel="up">Wisdom</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Forgetting-Wisdom-1"></span><h4 class="subsection">4.7.3 Forgetting Wisdom</h4>
<div class="example">
<pre class="example">void fftw_forget_wisdom(void);
</pre></div>
<span id="index-fftw_005fforget_005fwisdom-1"></span>
<p>Calling <code>fftw_forget_wisdom</code> causes all accumulated <code>wisdom</code>
to be discarded and its associated memory to be freed. (New
<code>wisdom</code> can still be gathered subsequently, however.)
</p>
</body>
</html>

200
fftw-3.3.10/doc/html/Fortran-Examples.html Normal file
View File

@@ -0,0 +1,200 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Fortran Examples (FFTW 3.3.10)</title>
<meta name="description" content="Fortran Examples (FFTW 3.3.10)">
<meta name="keywords" content="Fortran Examples (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Legacy-Fortran.html" rel="up" title="Calling FFTW from Legacy Fortran">
<link href="Wisdom-of-Fortran_003f.html" rel="next" title="Wisdom of Fortran?">
<link href="FFTW-Execution-in-Fortran.html" rel="prev" title="FFTW Execution in Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Fortran-Examples"></span><div class="header">
<p>
Next: <a href="Wisdom-of-Fortran_003f.html" accesskey="n" rel="next">Wisdom of Fortran?</a>, Previous: <a href="FFTW-Execution-in-Fortran.html" accesskey="p" rel="prev">FFTW Execution in Fortran</a>, Up: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="u" rel="up">Calling FFTW from Legacy Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Fortran-Examples-1"></span><h3 class="section">8.4 Fortran Examples</h3>
<p>In C, you might have something like the following to transform a
one-dimensional complex array:
</p>
<div class="example">
<pre class="example"> fftw_complex in[N], out[N];
fftw_plan plan;
plan = fftw_plan_dft_1d(N,in,out,FFTW_FORWARD,FFTW_ESTIMATE);
fftw_execute(plan);
fftw_destroy_plan(plan);
</pre></div>
<p>In Fortran, you would use the following to accomplish the same thing:
</p>
<div class="example">
<pre class="example"> double complex in, out
dimension in(N), out(N)
integer*8 plan
call dfftw_plan_dft_1d(plan,N,in,out,FFTW_FORWARD,FFTW_ESTIMATE)
call dfftw_execute_dft(plan, in, out)
call dfftw_destroy_plan(plan)
</pre></div>
<span id="index-dfftw_005fplan_005fdft_005f1d"></span>
<span id="index-dfftw_005fexecute_005fdft-1"></span>
<span id="index-dfftw_005fdestroy_005fplan"></span>
<p>Notice how all routines are called as Fortran subroutines, and the
plan is returned via the first argument to <code>dfftw_plan_dft_1d</code>.
Notice also that we changed <code>fftw_execute</code> to
<code>dfftw_execute_dft</code> (see <a href="FFTW-Execution-in-Fortran.html">FFTW Execution in Fortran</a>). To do
the same thing, but using 8 threads in parallel (see <a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a>), you would simply prefix these calls with:
</p>
<div class="example">
<pre class="example"> integer iret
call dfftw_init_threads(iret)
call dfftw_plan_with_nthreads(8)
</pre></div>
<span id="index-dfftw_005finit_005fthreads"></span>
<span id="index-dfftw_005fplan_005fwith_005fnthreads"></span>
<p>(You might want to check the value of <code>iret</code>: if it is zero, it
indicates an unlikely error during thread initialization.)
</p>
<p>To check the number of threads currently being used by the planner, you
can do the following:
</p>
<div class="example">
<pre class="example"> integer iret
call dfftw_planner_nthreads(iret)
</pre></div>
<span id="index-dfftw_005fplanner_005fnthreads"></span>
<p>To transform a three-dimensional array in-place with C, you might do:
</p>
<div class="example">
<pre class="example"> fftw_complex arr[L][M][N];
fftw_plan plan;
plan = fftw_plan_dft_3d(L,M,N, arr,arr,
FFTW_FORWARD, FFTW_ESTIMATE);
fftw_execute(plan);
fftw_destroy_plan(plan);
</pre></div>
<p>In Fortran, you would use this instead:
</p>
<div class="example">
<pre class="example"> double complex arr
dimension arr(L,M,N)
integer*8 plan
call dfftw_plan_dft_3d(plan, L,M,N, arr,arr,
&amp; FFTW_FORWARD, FFTW_ESTIMATE)
call dfftw_execute_dft(plan, arr, arr)
call dfftw_destroy_plan(plan)
</pre></div>
<span id="index-dfftw_005fplan_005fdft_005f3d"></span>
<p>Note that we pass the array dimensions in the &ldquo;natural&rdquo; order in both C
and Fortran.
</p>
<p>To transform a one-dimensional real array in Fortran, you might do:
</p>
<div class="example">
<pre class="example"> double precision in
dimension in(N)
double complex out
dimension out(N/2 + 1)
integer*8 plan
call dfftw_plan_dft_r2c_1d(plan,N,in,out,FFTW_ESTIMATE)
call dfftw_execute_dft_r2c(plan, in, out)
call dfftw_destroy_plan(plan)
</pre></div>
<span id="index-dfftw_005fplan_005fdft_005fr2c_005f1d"></span>
<span id="index-dfftw_005fexecute_005fdft_005fr2c"></span>
<p>To transform a two-dimensional real array, out of place, you might use
the following:
</p>
<div class="example">
<pre class="example"> double precision in
dimension in(M,N)
double complex out
dimension out(M/2 + 1, N)
integer*8 plan
call dfftw_plan_dft_r2c_2d(plan,M,N,in,out,FFTW_ESTIMATE)
call dfftw_execute_dft_r2c(plan, in, out)
call dfftw_destroy_plan(plan)
</pre></div>
<span id="index-dfftw_005fplan_005fdft_005fr2c_005f2d"></span>
<p><strong>Important:</strong> Notice that it is the <em>first</em> dimension of the
complex output array that is cut in half in Fortran, rather than the
last dimension as in C. This is a consequence of the interface routines
reversing the order of the array dimensions passed to FFTW so that the
Fortran program can use its ordinary column-major order.
<span id="index-column_002dmajor-3"></span>
<span id="index-r2c_002fc2r-multi_002ddimensional-array-format-3"></span>
</p>
<hr>
<div class="header">
<p>
Next: <a href="Wisdom-of-Fortran_003f.html" accesskey="n" rel="next">Wisdom of Fortran?</a>, Previous: <a href="FFTW-Execution-in-Fortran.html" accesskey="p" rel="prev">FFTW Execution in Fortran</a>, Up: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="u" rel="up">Calling FFTW from Legacy Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

162
fftw-3.3.10/doc/html/Fortran_002dinterface-routines.html Normal file
View File

@@ -0,0 +1,162 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Fortran-interface routines (FFTW 3.3.10)</title>
<meta name="description" content="Fortran-interface routines (FFTW 3.3.10)">
<meta name="keywords" content="Fortran-interface routines (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Legacy-Fortran.html" rel="up" title="Calling FFTW from Legacy Fortran">
<link href="FFTW-Constants-in-Fortran.html" rel="next" title="FFTW Constants in Fortran">
<link href="Calling-FFTW-from-Legacy-Fortran.html" rel="prev" title="Calling FFTW from Legacy Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Fortran_002dinterface-routines"></span><div class="header">
<p>
Next: <a href="FFTW-Constants-in-Fortran.html" accesskey="n" rel="next">FFTW Constants in Fortran</a>, Previous: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="p" rel="prev">Calling FFTW from Legacy Fortran</a>, Up: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="u" rel="up">Calling FFTW from Legacy Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Fortran_002dinterface-routines-1"></span><h3 class="section">8.1 Fortran-interface routines</h3>
<p>Nearly all of the FFTW functions have Fortran-callable equivalents.
The name of the legacy Fortran routine is the same as that of the
corresponding C routine, but with the &lsquo;<samp>fftw_</samp>&rsquo; prefix replaced by
&lsquo;<samp>dfftw_</samp>&rsquo;.<a id="DOCF9" href="#FOOT9"><sup>9</sup></a> The single and long-double precision
versions use &lsquo;<samp>sfftw_</samp>&rsquo; and &lsquo;<samp>lfftw_</samp>&rsquo;, respectively, instead of
&lsquo;<samp>fftwf_</samp>&rsquo; and &lsquo;<samp>fftwl_</samp>&rsquo;; quadruple precision (<code>real*16</code>)
is available on some systems as &lsquo;<samp>fftwq_</samp>&rsquo; (see <a href="Precision.html">Precision</a>).
(Note that <code>long double</code> on x86 hardware is usually at most
80-bit extended precision, <em>not</em> quadruple precision.)
</p>
<p>For the most part, all of the arguments to the functions are the same,
with the following exceptions:
</p>
<ul>
<li> <code>plan</code> variables (what would be of type <code>fftw_plan</code> in C),
must be declared as a type that is at least as big as a pointer
(address) on your machine. We recommend using <code>integer*8</code> everywhere,
since this should always be big enough.
<span id="index-portability-6"></span>
</li><li> Any function that returns a value (e.g. <code>fftw_plan_dft</code>) is
converted into a <em>subroutine</em>. The return value is converted into
an additional <em>first</em> parameter of this subroutine.<a id="DOCF10" href="#FOOT10"><sup>10</sup></a>
</li><li> <span id="index-column_002dmajor-2"></span>
The Fortran routines expect multi-dimensional arrays to be in
<em>column-major</em> order, which is the ordinary format of Fortran
arrays (see <a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>). They do this
transparently and costlessly simply by reversing the order of the
dimensions passed to FFTW, but this has one important consequence for
multi-dimensional real-complex transforms, discussed below.
</li><li> Wisdom import and export is somewhat more tricky because one cannot
easily pass files or strings between C and Fortran; see <a href="Wisdom-of-Fortran_003f.html">Wisdom of Fortran?</a>.
</li><li> Legacy Fortran cannot use the <code>fftw_malloc</code> dynamic-allocation routine.
If you want to exploit the SIMD FFTW (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>), you&rsquo;ll
need to figure out some other way to ensure that your arrays are at
least 16-byte aligned.
</li><li> <span id="index-fftw_005fiodim-2"></span>
<span id="index-guru-interface-4"></span>
Since Fortran 77 does not have data structures, the <code>fftw_iodim</code>
structure from the guru interface (see <a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a>) must be split into separate arguments. In particular, any
<code>fftw_iodim</code> array arguments in the C guru interface become three
integer array arguments (<code>n</code>, <code>is</code>, and <code>os</code>) in the
Fortran guru interface, all of whose lengths should be equal to the
corresponding <code>rank</code> argument.
</li><li> The guru planner interface in Fortran does <em>not</em> do any automatic
translation between column-major and row-major; you are responsible
for setting the strides etcetera to correspond to your Fortran arrays.
However, as a slight bug that we are preserving for backwards
compatibility, the &lsquo;<samp>plan_guru_r2r</samp>&rsquo; in Fortran <em>does</em> reverse the
order of its <code>kind</code> array parameter, so the <code>kind</code> array
of that routine should be in the reverse of the order of the iodim
arrays (see above).
</li></ul>
<p>In general, you should take care to use Fortran data types that
correspond to (i.e. are the same size as) the C types used by FFTW.
In practice, this correspondence is usually straightforward
(i.e. <code>integer</code> corresponds to <code>int</code>, <code>real</code>
corresponds to <code>float</code>, etcetera). The native Fortran
double/single-precision complex type should be compatible with
<code>fftw_complex</code>/<code>fftwf_complex</code>. Such simple correspondences
are assumed in the examples below.
<span id="index-portability-7"></span>
</p>
<div class="footnote">
<hr>
<h4 class="footnotes-heading">Footnotes</h4>
<h5><a id="FOOT9" href="#DOCF9">(9)</a></h3>
<p>Technically, Fortran 77 identifiers are not
allowed to have more than 6 characters, nor may they contain
underscores. Any compiler that enforces this limitation doesn&rsquo;t
deserve to link to FFTW.</p>
<h5><a id="FOOT10" href="#DOCF10">(10)</a></h3>
<p>The
reason for this is that some Fortran implementations seem to have
trouble with C function return values, and vice versa.</p>
</div>
<hr>
<div class="header">
<p>
Next: <a href="FFTW-Constants-in-Fortran.html" accesskey="n" rel="next">FFTW Constants in Fortran</a>, Previous: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="p" rel="prev">Calling FFTW from Legacy Fortran</a>, Up: <a href="Calling-FFTW-from-Legacy-Fortran.html" accesskey="u" rel="up">Calling FFTW from Legacy Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

119
fftw-3.3.10/doc/html/Generating-your-own-code.html Normal file
View File

@@ -0,0 +1,119 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Generating your own code (FFTW 3.3.10)</title>
<meta name="description" content="Generating your own code (FFTW 3.3.10)">
<meta name="keywords" content="Generating your own code (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Installation-and-Customization.html" rel="up" title="Installation and Customization">
<link href="Acknowledgments.html" rel="next" title="Acknowledgments">
<link href="Cycle-Counters.html" rel="prev" title="Cycle Counters">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Generating-your-own-code"></span><div class="header">
<p>
Previous: <a href="Cycle-Counters.html" accesskey="p" rel="prev">Cycle Counters</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Generating-your-own-code-1"></span><h3 class="section">10.4 Generating your own code</h3>
<span id="index-code-generator-1"></span>
<p>The directory <code>genfft</code> contains the programs that were used to
generate FFTW&rsquo;s &ldquo;codelets,&rdquo; which are hard-coded transforms of small
sizes.
<span id="index-codelet-2"></span>
We do not expect casual users to employ the generator, which is a rather
sophisticated program that generates directed acyclic graphs of FFT
algorithms and performs algebraic simplifications on them. It was
written in Objective Caml, a dialect of ML, which is available at
<a href="http://caml.inria.fr/ocaml/index.en.html">http://caml.inria.fr/ocaml/index.en.html</a>.
<span id="index-Caml"></span>
</p>
<p>If you have Objective Caml installed (along with recent versions of
GNU <code>autoconf</code>, <code>automake</code>, and <code>libtool</code>), then you
can change the set of codelets that are generated or play with the
generation options. The set of generated codelets is specified by the
<code>{dft,rdft}/{codelets,simd}/*/Makefile.am</code> files. For example, you can add
efficient REDFT codelets of small sizes by modifying
<code>rdft/codelets/r2r/Makefile.am</code>.
<span id="index-REDFT-2"></span>
After you modify any <code>Makefile.am</code> files, you can type <code>sh
bootstrap.sh</code> in the top-level directory followed by <code>make</code> to
re-generate the files.
</p>
<p>We do not provide more details about the code-generation process, since
we do not expect that most users will need to generate their own code.
However, feel free to contact us at <a href="mailto:fftw@fftw.org">fftw@fftw.org</a> if
you are interested in the subject.
</p>
<span id="index-monadic-programming"></span>
<p>You might find it interesting to learn Caml and/or some modern
programming techniques that we used in the generator (including monadic
programming), especially if you heard the rumor that Java and
object-oriented programming are the latest advancement in the field.
The internal operation of the codelet generator is described in the
paper, &ldquo;A Fast Fourier Transform Compiler,&rdquo; by M. Frigo, which is
available from the <a href="http://www.fftw.org">FFTW home page</a> and also
appeared in the <cite>Proceedings of the 1999 ACM SIGPLAN Conference on
Programming Language Design and Implementation (PLDI)</cite>.
</p>
<hr>
<div class="header">
<p>
Previous: <a href="Cycle-Counters.html" accesskey="p" rel="prev">Cycle Counters</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

149
fftw-3.3.10/doc/html/Guru-Complex-DFTs.html Normal file
View File

@@ -0,0 +1,149 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Guru Complex DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Guru Complex DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Guru Complex DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Guru-Interface.html" rel="up" title="Guru Interface">
<link href="Guru-Real_002ddata-DFTs.html" rel="next" title="Guru Real-data DFTs">
<link href="Guru-vector-and-transform-sizes.html" rel="prev" title="Guru vector and transform sizes">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Guru-Complex-DFTs"></span><div class="header">
<p>
Next: <a href="Guru-Real_002ddata-DFTs.html" accesskey="n" rel="next">Guru Real-data DFTs</a>, Previous: <a href="Guru-vector-and-transform-sizes.html" accesskey="p" rel="prev">Guru vector and transform sizes</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Guru-Complex-DFTs-1"></span><h4 class="subsection">4.5.3 Guru Complex DFTs</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_guru_dft(
int rank, const fftw_iodim *dims,
int howmany_rank, const fftw_iodim *howmany_dims,
fftw_complex *in, fftw_complex *out,
int sign, unsigned flags);
fftw_plan fftw_plan_guru_split_dft(
int rank, const fftw_iodim *dims,
int howmany_rank, const fftw_iodim *howmany_dims,
double *ri, double *ii, double *ro, double *io,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fguru_005fdft"></span>
<span id="index-fftw_005fplan_005fguru_005fsplit_005fdft"></span>
<p>These two functions plan a complex-data, multi-dimensional DFT
for the interleaved and split format, respectively.
Transform dimensions are given by (<code>rank</code>, <code>dims</code>) over a
multi-dimensional vector (loop) of dimensions (<code>howmany_rank</code>,
<code>howmany_dims</code>). <code>dims</code> and <code>howmany_dims</code> should point
to <code>fftw_iodim</code> arrays of length <code>rank</code> and
<code>howmany_rank</code>, respectively.
</p>
<span id="index-flags-5"></span>
<p><code>flags</code> is a bitwise OR (&lsquo;<samp>|</samp>&rsquo;) of zero or more planner flags,
as defined in <a href="Planner-Flags.html">Planner Flags</a>.
</p>
<p>In the <code>fftw_plan_guru_dft</code> function, the pointers <code>in</code> and
<code>out</code> point to the interleaved input and output arrays,
respectively. The sign can be either <em>-1</em> (=
<code>FFTW_FORWARD</code>) or <em>+1</em> (= <code>FFTW_BACKWARD</code>). If the
pointers are equal, the transform is in-place.
</p>
<p>In the <code>fftw_plan_guru_split_dft</code> function,
<code>ri</code> and <code>ii</code> point to the real and imaginary input arrays,
and <code>ro</code> and <code>io</code> point to the real and imaginary output
arrays. The input and output pointers may be the same, indicating an
in-place transform. For example, for <code>fftw_complex</code> pointers
<code>in</code> and <code>out</code>, the corresponding parameters are:
</p>
<div class="example">
<pre class="example">ri = (double *) in;
ii = (double *) in + 1;
ro = (double *) out;
io = (double *) out + 1;
</pre></div>
<p>Because <code>fftw_plan_guru_split_dft</code> accepts split arrays, strides
are expressed in units of <code>double</code>. For a contiguous
<code>fftw_complex</code> array, the overall stride of the transform should
be 2, the distance between consecutive real parts or between
consecutive imaginary parts; see <a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a>. Note that the dimension strides are applied equally to the
real and imaginary parts; real and imaginary arrays with different
strides are not supported.
</p>
<p>There is no <code>sign</code> parameter in <code>fftw_plan_guru_split_dft</code>.
This function always plans for an <code>FFTW_FORWARD</code> transform. To
plan for an <code>FFTW_BACKWARD</code> transform, you can exploit the
identity that the backwards DFT is equal to the forwards DFT with the
real and imaginary parts swapped. For example, in the case of the
<code>fftw_complex</code> arrays above, the <code>FFTW_BACKWARD</code> transform
is computed by the parameters:
</p>
<div class="example">
<pre class="example">ri = (double *) in + 1;
ii = (double *) in;
ro = (double *) out + 1;
io = (double *) out;
</pre></div>
<hr>
<div class="header">
<p>
Next: <a href="Guru-Real_002ddata-DFTs.html" accesskey="n" rel="next">Guru Real-data DFTs</a>, Previous: <a href="Guru-vector-and-transform-sizes.html" accesskey="p" rel="prev">Guru vector and transform sizes</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

102
fftw-3.3.10/doc/html/Guru-Interface.html Normal file
View File

@@ -0,0 +1,102 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Guru Interface (FFTW 3.3.10)</title>
<meta name="description" content="Guru Interface (FFTW 3.3.10)">
<meta name="keywords" content="Guru Interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-Reference.html" rel="up" title="FFTW Reference">
<link href="Interleaved-and-split-arrays.html" rel="next" title="Interleaved and split arrays">
<link href="Advanced-Real_002dto_002dreal-Transforms.html" rel="prev" title="Advanced Real-to-real Transforms">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Guru-Interface"></span><div class="header">
<p>
Next: <a href="New_002darray-Execute-Functions.html" accesskey="n" rel="next">New-array Execute Functions</a>, Previous: <a href="Advanced-Interface.html" accesskey="p" rel="prev">Advanced Interface</a>, Up: <a href="FFTW-Reference.html" accesskey="u" rel="up">FFTW Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Guru-Interface-1"></span><h3 class="section">4.5 Guru Interface</h3>
<span id="index-guru-interface-2"></span>
<p>The &ldquo;guru&rdquo; interface to FFTW is intended to expose as much as possible
of the flexibility in the underlying FFTW architecture. It allows one
to compute multi-dimensional &ldquo;vectors&rdquo; (loops) of multi-dimensional
transforms, where each vector/transform dimension has an independent
size and stride.
<span id="index-vector"></span>
One can also use more general complex-number formats, e.g. separate real
and imaginary arrays.
</p>
<p>For those users who require the flexibility of the guru interface, it is
important that they pay special attention to the documentation lest they
shoot themselves in the foot.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Interleaved-and-split-arrays.html" accesskey="1">Interleaved and split arrays</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Guru-vector-and-transform-sizes.html" accesskey="2">Guru vector and transform sizes</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Guru-Complex-DFTs.html" accesskey="3">Guru Complex DFTs</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Guru-Real_002ddata-DFTs.html" accesskey="4">Guru Real-data DFTs</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Guru-Real_002dto_002dreal-Transforms.html" accesskey="5">Guru Real-to-real Transforms</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="64_002dbit-Guru-Interface.html" accesskey="6">64-bit Guru Interface</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

148
fftw-3.3.10/doc/html/Guru-Real_002ddata-DFTs.html Normal file
View File

@@ -0,0 +1,148 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Guru Real-data DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Guru Real-data DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Guru Real-data DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Guru-Interface.html" rel="up" title="Guru Interface">
<link href="Guru-Real_002dto_002dreal-Transforms.html" rel="next" title="Guru Real-to-real Transforms">
<link href="Guru-Complex-DFTs.html" rel="prev" title="Guru Complex DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Guru-Real_002ddata-DFTs"></span><div class="header">
<p>
Next: <a href="Guru-Real_002dto_002dreal-Transforms.html" accesskey="n" rel="next">Guru Real-to-real Transforms</a>, Previous: <a href="Guru-Complex-DFTs.html" accesskey="p" rel="prev">Guru Complex DFTs</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Guru-Real_002ddata-DFTs-1"></span><h4 class="subsection">4.5.4 Guru Real-data DFTs</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_guru_dft_r2c(
int rank, const fftw_iodim *dims,
int howmany_rank, const fftw_iodim *howmany_dims,
double *in, fftw_complex *out,
unsigned flags);
fftw_plan fftw_plan_guru_split_dft_r2c(
int rank, const fftw_iodim *dims,
int howmany_rank, const fftw_iodim *howmany_dims,
double *in, double *ro, double *io,
unsigned flags);
fftw_plan fftw_plan_guru_dft_c2r(
int rank, const fftw_iodim *dims,
int howmany_rank, const fftw_iodim *howmany_dims,
fftw_complex *in, double *out,
unsigned flags);
fftw_plan fftw_plan_guru_split_dft_c2r(
int rank, const fftw_iodim *dims,
int howmany_rank, const fftw_iodim *howmany_dims,
double *ri, double *ii, double *out,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fguru_005fdft_005fr2c"></span>
<span id="index-fftw_005fplan_005fguru_005fsplit_005fdft_005fr2c"></span>
<span id="index-fftw_005fplan_005fguru_005fdft_005fc2r"></span>
<span id="index-fftw_005fplan_005fguru_005fsplit_005fdft_005fc2r"></span>
<p>Plan a real-input (r2c) or real-output (c2r), multi-dimensional DFT with
transform dimensions given by (<code>rank</code>, <code>dims</code>) over a
multi-dimensional vector (loop) of dimensions (<code>howmany_rank</code>,
<code>howmany_dims</code>). <code>dims</code> and <code>howmany_dims</code> should point
to <code>fftw_iodim</code> arrays of length <code>rank</code> and
<code>howmany_rank</code>, respectively. As for the basic and advanced
interfaces, an r2c transform is <code>FFTW_FORWARD</code> and a c2r transform
is <code>FFTW_BACKWARD</code>.
</p>
<p>The <em>last</em> dimension of <code>dims</code> is interpreted specially:
that dimension of the real array has size <code>dims[rank-1].n</code>, but
that dimension of the complex array has size <code>dims[rank-1].n/2+1</code>
(division rounded down). The strides, on the other hand, are taken to
be exactly 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-<code>NULL</code>) for
any dimensions other than those described in <a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a> and generalized in <a href="Advanced-Real_002ddata-DFTs.html">Advanced Real-data DFTs</a>. (That is,
for an in-place transform, each individual dimension should be able to
operate in place.)
<span id="index-in_002dplace-6"></span>
</p>
<p><code>in</code> and <code>out</code> point to the input and output arrays for r2c
and c2r transforms, respectively. For split arrays, <code>ri</code> and
<code>ii</code> point to the real and imaginary input arrays for a c2r
transform, and <code>ro</code> and <code>io</code> point to the real and imaginary
output arrays for an r2c transform. <code>in</code> and <code>ro</code> or
<code>ri</code> and <code>out</code> may be the same, indicating an in-place
transform. (In-place transforms where <code>in</code> and <code>io</code> or
<code>ii</code> and <code>out</code> are the same are not currently supported.)
</p>
<span id="index-flags-6"></span>
<p><code>flags</code> is a bitwise OR (&lsquo;<samp>|</samp>&rsquo;) of zero or more planner flags,
as defined in <a href="Planner-Flags.html">Planner Flags</a>.
</p>
<p>In-place transforms of rank greater than 1 are currently only
supported for interleaved arrays. For split arrays, the planner will
return <code>NULL</code>.
<span id="index-in_002dplace-7"></span>
</p>
<hr>
<div class="header">
<p>
Next: <a href="Guru-Real_002dto_002dreal-Transforms.html" accesskey="n" rel="next">Guru Real-to-real Transforms</a>, Previous: <a href="Guru-Complex-DFTs.html" accesskey="p" rel="prev">Guru Complex DFTs</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

101
fftw-3.3.10/doc/html/Guru-Real_002dto_002dreal-Transforms.html Normal file
View File

@@ -0,0 +1,101 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Guru Real-to-real Transforms (FFTW 3.3.10)</title>
<meta name="description" content="Guru Real-to-real Transforms (FFTW 3.3.10)">
<meta name="keywords" content="Guru Real-to-real Transforms (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Guru-Interface.html" rel="up" title="Guru Interface">
<link href="64_002dbit-Guru-Interface.html" rel="next" title="64-bit Guru Interface">
<link href="Guru-Real_002ddata-DFTs.html" rel="prev" title="Guru Real-data DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Guru-Real_002dto_002dreal-Transforms"></span><div class="header">
<p>
Next: <a href="64_002dbit-Guru-Interface.html" accesskey="n" rel="next">64-bit Guru Interface</a>, Previous: <a href="Guru-Real_002ddata-DFTs.html" accesskey="p" rel="prev">Guru Real-data DFTs</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Guru-Real_002dto_002dreal-Transforms-1"></span><h4 class="subsection">4.5.5 Guru Real-to-real Transforms</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_guru_r2r(int rank, const fftw_iodim *dims,
int howmany_rank,
const fftw_iodim *howmany_dims,
double *in, double *out,
const fftw_r2r_kind *kind,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fguru_005fr2r"></span>
<p>Plan a real-to-real (r2r) multi-dimensional <code>FFTW_FORWARD</code>
transform with transform dimensions given by (<code>rank</code>, <code>dims</code>)
over a multi-dimensional vector (loop) of dimensions
(<code>howmany_rank</code>, <code>howmany_dims</code>). <code>dims</code> and
<code>howmany_dims</code> should point to <code>fftw_iodim</code> arrays of length
<code>rank</code> and <code>howmany_rank</code>, respectively.
</p>
<p>The transform kind of each dimension is given by the <code>kind</code>
parameter, which should point to an array of length <code>rank</code>. Valid
<code>fftw_r2r_kind</code> constants are given in <a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a>.
</p>
<p><code>in</code> and <code>out</code> point to the real input and output arrays; they
may be the same, indicating an in-place transform.
</p>
<span id="index-flags-7"></span>
<p><code>flags</code> is a bitwise OR (&lsquo;<samp>|</samp>&rsquo;) of zero or more planner flags,
as defined in <a href="Planner-Flags.html">Planner Flags</a>.
</p>
</body>
</html>

142
fftw-3.3.10/doc/html/Guru-vector-and-transform-sizes.html Normal file
View File

@@ -0,0 +1,142 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Guru vector and transform sizes (FFTW 3.3.10)</title>
<meta name="description" content="Guru vector and transform sizes (FFTW 3.3.10)">
<meta name="keywords" content="Guru vector and transform sizes (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Guru-Interface.html" rel="up" title="Guru Interface">
<link href="Guru-Complex-DFTs.html" rel="next" title="Guru Complex DFTs">
<link href="Interleaved-and-split-arrays.html" rel="prev" title="Interleaved and split arrays">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Guru-vector-and-transform-sizes"></span><div class="header">
<p>
Next: <a href="Guru-Complex-DFTs.html" accesskey="n" rel="next">Guru Complex DFTs</a>, Previous: <a href="Interleaved-and-split-arrays.html" accesskey="p" rel="prev">Interleaved and split arrays</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Guru-vector-and-transform-sizes-1"></span><h4 class="subsection">4.5.2 Guru vector and transform sizes</h4>
<p>The guru interface introduces one basic new data structure,
<code>fftw_iodim</code>, that is used to specify sizes and strides for
multi-dimensional transforms and vectors:
</p>
<div class="example">
<pre class="example">typedef struct {
int n;
int is;
int os;
} fftw_iodim;
</pre></div>
<span id="index-fftw_005fiodim"></span>
<p>Here, <code>n</code> is the size of the dimension, and <code>is</code> and <code>os</code>
are the strides of that dimension for the input and output arrays. (The
stride is the separation of consecutive elements along this dimension.)
</p>
<p>The meaning of the stride parameter depends on the type of the array
that the stride refers to. <em>If the array is interleaved complex,
strides are expressed in units of complex numbers
(<code>fftw_complex</code>). If the array is split complex or real, strides
are expressed in units of real numbers (<code>double</code>).</em> This
convention is consistent with the usual pointer arithmetic in the C
language. An interleaved array is denoted by a pointer <code>p</code> to
<code>fftw_complex</code>, so that <code>p+1</code> points to the next complex
number. Split arrays are denoted by pointers to <code>double</code>, in
which case pointer arithmetic operates in units of
<code>sizeof(double)</code>.
<span id="index-stride-2"></span>
</p>
<p>The guru planner interfaces all take a (<code>rank</code>, <code>dims[rank]</code>)
pair describing the transform size, and a (<code>howmany_rank</code>,
<code>howmany_dims[howmany_rank]</code>) pair describing the &ldquo;vector&rdquo; size (a
multi-dimensional loop of transforms to perform), where <code>dims</code> and
<code>howmany_dims</code> are arrays of <code>fftw_iodim</code>. Each <code>n</code> field must
be positive for <code>dims</code> and nonnegative for <code>howmany_dims</code>, while both
<code>rank</code> and <code>howmany_rank</code> must be nonnegative.
</p>
<p>For example, the <code>howmany</code> parameter in the advanced complex-DFT
interface corresponds to <code>howmany_rank</code> = 1,
<code>howmany_dims[0].n</code> = <code>howmany</code>, <code>howmany_dims[0].is</code> =
<code>idist</code>, and <code>howmany_dims[0].os</code> = <code>odist</code>.
<span id="index-howmany-loop"></span>
<span id="index-dist-1"></span>
(To compute a single transform, you can just use <code>howmany_rank</code> = 0.)
</p>
<p>A row-major multidimensional array with dimensions <code>n[rank]</code>
(see <a href="Row_002dmajor-Format.html">Row-major Format</a>) corresponds to <code>dims[i].n</code> =
<code>n[i]</code> and the recurrence <code>dims[i].is</code> = <code>n[i+1] *
dims[i+1].is</code> (similarly for <code>os</code>). The stride of the last
(<code>i=rank-1</code>) dimension is the overall stride of the array.
e.g. to be equivalent to the advanced complex-DFT interface, you would
have <code>dims[rank-1].is</code> = <code>istride</code> and
<code>dims[rank-1].os</code> = <code>ostride</code>.
<span id="index-row_002dmajor-3"></span>
</p>
<p>In general, we only guarantee FFTW to return a non-<code>NULL</code> plan if
the vector and transform dimensions correspond to a set of distinct
indices, and for in-place transforms the input/output strides should
be the same.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Guru-Complex-DFTs.html" accesskey="n" rel="next">Guru Complex DFTs</a>, Previous: <a href="Interleaved-and-split-arrays.html" accesskey="p" rel="prev">Interleaved and split arrays</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

91
fftw-3.3.10/doc/html/How-Many-Threads-to-Use_003f.html Normal file
View File

@@ -0,0 +1,91 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>How Many Threads to Use? (FFTW 3.3.10)</title>
<meta name="description" content="How Many Threads to Use? (FFTW 3.3.10)">
<meta name="keywords" content="How Many Threads to Use? (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Multi_002dthreaded-FFTW.html" rel="up" title="Multi-threaded FFTW">
<link href="Thread-safety.html" rel="next" title="Thread safety">
<link href="Usage-of-Multi_002dthreaded-FFTW.html" rel="prev" title="Usage of Multi-threaded FFTW">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="How-Many-Threads-to-Use_003f"></span><div class="header">
<p>
Next: <a href="Thread-safety.html" accesskey="n" rel="next">Thread safety</a>, Previous: <a href="Usage-of-Multi_002dthreaded-FFTW.html" accesskey="p" rel="prev">Usage of Multi-threaded FFTW</a>, Up: <a href="Multi_002dthreaded-FFTW.html" accesskey="u" rel="up">Multi-threaded FFTW</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="How-Many-Threads-to-Use_003f-1"></span><h3 class="section">5.3 How Many Threads to Use?</h3>
<span id="index-number-of-threads"></span>
<p>There is a fair amount of overhead involved in synchronizing threads,
so the optimal number of threads to use depends upon the size of the
transform as well as on the number of processors you have.
</p>
<p>As a general rule, you don&rsquo;t want to use more threads than you have
processors. (Using more threads will work, but there will be extra
overhead with no benefit.) In fact, if the problem size is too small,
you may want to use fewer threads than you have processors.
</p>
<p>You will have to experiment with your system to see what level of
parallelization is best for your problem size. Typically, the problem
will have to involve at least a few thousand data points before threads
become beneficial. If you plan with <code>FFTW_PATIENT</code>, it will
automatically disable threads for sizes that don&rsquo;t benefit from
parallelization.
<span id="index-FFTW_005fPATIENT-3"></span>
</p>
</body>
</html>

121
fftw-3.3.10/doc/html/Installation-and-Customization.html Normal file
View File

@@ -0,0 +1,121 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Installation and Customization (FFTW 3.3.10)</title>
<meta name="description" content="Installation and Customization (FFTW 3.3.10)">
<meta name="keywords" content="Installation and Customization (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Installation-on-Unix.html" rel="next" title="Installation on Unix">
<link href="Upgrading-from-FFTW-version-2.html" rel="prev" title="Upgrading from FFTW version 2">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Installation-and-Customization"></span><div class="header">
<p>
Next: <a href="Acknowledgments.html" accesskey="n" rel="next">Acknowledgments</a>, Previous: <a href="Upgrading-from-FFTW-version-2.html" accesskey="p" rel="prev">Upgrading from FFTW version 2</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Installation-and-Customization-1"></span><h2 class="chapter">10 Installation and Customization</h2>
<span id="index-installation"></span>
<p>This chapter describes the installation and customization of FFTW, the
latest version of which may be downloaded from
<a href="http://www.fftw.org">the FFTW home page</a>.
</p>
<p>In principle, FFTW should work on any system with an ANSI C compiler
(<code>gcc</code> is fine). However, planner time is drastically reduced if
FFTW can exploit a hardware cycle counter; FFTW comes with cycle-counter
support for all modern general-purpose CPUs, but you may need to add a
couple of lines of code if your compiler is not yet supported
(see <a href="Cycle-Counters.html">Cycle Counters</a>). (On Unix, there will be a warning at the end
of the <code>configure</code> output if no cycle counter is found.)
<span id="index-cycle-counter"></span>
<span id="index-compiler-1"></span>
<span id="index-portability-9"></span>
</p>
<p>Installation of FFTW is simplest if you have a Unix or a GNU system,
such as GNU/Linux, and we describe this case in the first section below,
including the use of special configuration options to e.g. install
different precisions or exploit optimizations for particular
architectures (e.g. SIMD). Compilation on non-Unix systems is a more
manual process, but we outline the procedure in the second section. It
is also likely that pre-compiled binaries will be available for popular
systems.
</p>
<p>Finally, we describe how you can customize FFTW for particular needs by
generating <em>codelets</em> for fast transforms of sizes not supported
efficiently by the standard FFTW distribution.
<span id="index-codelet-1"></span>
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Installation-on-Unix.html" accesskey="1">Installation on Unix</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Installation-on-non_002dUnix-systems.html" accesskey="2">Installation on non-Unix systems</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Cycle-Counters.html" accesskey="3">Cycle Counters</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Generating-your-own-code.html" accesskey="4">Generating your own code</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<hr>
<div class="header">
<p>
Next: <a href="Acknowledgments.html" accesskey="n" rel="next">Acknowledgments</a>, Previous: <a href="Upgrading-from-FFTW-version-2.html" accesskey="p" rel="prev">Upgrading from FFTW version 2</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

106
fftw-3.3.10/doc/html/Installation-and-Supported-Hardware_002fSoftware.html Normal file
View File

@@ -0,0 +1,106 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Installation and Supported Hardware/Software (FFTW 3.3.10)</title>
<meta name="description" content="Installation and Supported Hardware/Software (FFTW 3.3.10)">
<meta name="keywords" content="Installation and Supported Hardware/Software (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Multi_002dthreaded-FFTW.html" rel="up" title="Multi-threaded FFTW">
<link href="Usage-of-Multi_002dthreaded-FFTW.html" rel="next" title="Usage of Multi-threaded FFTW">
<link href="Multi_002dthreaded-FFTW.html" rel="prev" title="Multi-threaded FFTW">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Installation-and-Supported-Hardware_002fSoftware"></span><div class="header">
<p>
Next: <a href="Usage-of-Multi_002dthreaded-FFTW.html" accesskey="n" rel="next">Usage of Multi-threaded FFTW</a>, Previous: <a href="Multi_002dthreaded-FFTW.html" accesskey="p" rel="prev">Multi-threaded FFTW</a>, Up: <a href="Multi_002dthreaded-FFTW.html" accesskey="u" rel="up">Multi-threaded FFTW</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Installation-and-Supported-Hardware_002fSoftware-1"></span><h3 class="section">5.1 Installation and Supported Hardware/Software</h3>
<p>All of the FFTW threads code is located in the <code>threads</code>
subdirectory of the FFTW package. On Unix systems, the FFTW threads
libraries and header files can be automatically configured, compiled,
and installed along with the uniprocessor FFTW libraries simply by
including <code>--enable-threads</code> in the flags to the <code>configure</code>
script (see <a href="Installation-on-Unix.html">Installation on Unix</a>), or <code>--enable-openmp</code> to use
<a href="http://www.openmp.org">OpenMP</a> threads.
<span id="index-configure"></span>
</p>
<span id="index-portability-3"></span>
<span id="index-OpenMP"></span>
<p>The threads routines require your operating system to have some sort
of shared-memory threads support. Specifically, the FFTW threads
package works with POSIX threads (available on most Unix variants,
from GNU/Linux to MacOS X) and Win32 threads. OpenMP threads, which
are supported in many common compilers (e.g. gcc) are also supported,
and may give better performance on some systems. (OpenMP threads are
also useful if you are employing OpenMP in your own code, in order to
minimize conflicts between threading models.) If you have a
shared-memory machine that uses a different threads API, it should be
a simple matter of programming to include support for it; see the file
<code>threads/threads.c</code> for more detail.
</p>
<p>You can compile FFTW with <em>both</em> <code>--enable-threads</code> and
<code>--enable-openmp</code> at the same time, since they install libraries
with different names (&lsquo;<samp>fftw3_threads</samp>&rsquo; and &lsquo;<samp>fftw3_omp</samp>&rsquo;, as
described below). However, your programs may only link to <em>one</em>
of these two libraries at a time.
</p>
<p>Ideally, of course, you should also have multiple processors in order to
get any benefit from the threaded transforms.
</p>
</body>
</html>

253
fftw-3.3.10/doc/html/Installation-on-Unix.html Normal file
View File

@@ -0,0 +1,253 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Installation on Unix (FFTW 3.3.10)</title>
<meta name="description" content="Installation on Unix (FFTW 3.3.10)">
<meta name="keywords" content="Installation on Unix (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Installation-and-Customization.html" rel="up" title="Installation and Customization">
<link href="Installation-on-non_002dUnix-systems.html" rel="next" title="Installation on non-Unix systems">
<link href="Installation-and-Customization.html" rel="prev" title="Installation and Customization">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Installation-on-Unix"></span><div class="header">
<p>
Next: <a href="Installation-on-non_002dUnix-systems.html" accesskey="n" rel="next">Installation on non-Unix systems</a>, Previous: <a href="Installation-and-Customization.html" accesskey="p" rel="prev">Installation and Customization</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Installation-on-Unix-1"></span><h3 class="section">10.1 Installation on Unix</h3>
<p>FFTW comes with a <code>configure</code> program in the GNU style.
Installation can be as simple as:
<span id="index-configure-2"></span>
</p>
<div class="example">
<pre class="example">./configure
make
make install
</pre></div>
<p>This will build the uniprocessor complex and real transform libraries
along with the test programs. (We recommend that you use GNU
<code>make</code> if it is available; on some systems it is called
<code>gmake</code>.) The &ldquo;<code>make install</code>&rdquo; command installs the fftw
and rfftw libraries in standard places, and typically requires root
privileges (unless you specify a different install directory with the
<code>--prefix</code> flag to <code>configure</code>). You can also type
&ldquo;<code>make check</code>&rdquo; to put the FFTW test programs through their paces.
If you have problems during configuration or compilation, you may want
to run &ldquo;<code>make distclean</code>&rdquo; before trying again; this ensures that
you don&rsquo;t have any stale files left over from previous compilation
attempts.
</p>
<p>The <code>configure</code> script chooses the <code>gcc</code> compiler by default,
if it is available; you can select some other compiler with:
</p><div class="example">
<pre class="example">./configure CC=&quot;<span class="roman"><i>&lt;the name of your C compiler&gt;</i></span>&quot;
</pre></div>
<p>The <code>configure</code> script knows good <code>CFLAGS</code> (C compiler flags)
<span id="index-compiler-flags"></span>
for a few systems. If your system is not known, the <code>configure</code>
script will print out a warning. In this case, you should re-configure
FFTW with the command
</p><div class="example">
<pre class="example">./configure CFLAGS=&quot;<span class="roman"><i>&lt;write your CFLAGS here&gt;</i></span>&quot;
</pre></div>
<p>and then compile as usual. If you do find an optimal set of
<code>CFLAGS</code> for your system, please let us know what they are (along
with the output of <code>config.guess</code>) so that we can include them in
future releases.
</p>
<p><code>configure</code> supports all the standard flags defined by the GNU
Coding Standards; see the <code>INSTALL</code> file in FFTW or
<a href="http://www.gnu.org/prep/standards/html_node/index.html">the GNU web page</a>.
Note especially <code>--help</code> to list all flags and
<code>--enable-shared</code> to create shared, rather than static, libraries.
<code>configure</code> also accepts a few FFTW-specific flags, particularly:
</p>
<ul>
<li> <span id="index-precision-9"></span>
<code>--enable-float</code>: Produces a single-precision version of FFTW
(<code>float</code>) instead of the default double-precision (<code>double</code>).
See <a href="Precision.html">Precision</a>.
</li><li> <span id="index-precision-10"></span>
<code>--enable-long-double</code>: Produces a long-double precision version of
FFTW (<code>long double</code>) instead of the default double-precision
(<code>double</code>). The <code>configure</code> script will halt with an error
message if <code>long double</code> is the same size as <code>double</code> on your
machine/compiler. See <a href="Precision.html">Precision</a>.
</li><li> <span id="index-precision-11"></span>
<code>--enable-quad-precision</code>: Produces a quadruple-precision version
of FFTW using the nonstandard <code>__float128</code> type provided by
<code>gcc</code> 4.6 or later on x86, x86-64, and Itanium architectures,
instead of the default double-precision (<code>double</code>). The
<code>configure</code> script will halt with an error message if the
compiler is not <code>gcc</code> version 4.6 or later or if <code>gcc</code>&rsquo;s
<code>libquadmath</code> library is not installed. See <a href="Precision.html">Precision</a>.
</li><li> <span id="index-threads-3"></span>
<code>--enable-threads</code>: Enables compilation and installation of the
FFTW threads library (see <a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a>), which provides a
simple interface to parallel transforms for SMP systems. By default,
the threads routines are not compiled.
</li><li> <code>--enable-openmp</code>: Like <code>--enable-threads</code>, but using OpenMP
compiler directives in order to induce parallelism rather than
spawning its own threads directly, and installing an &lsquo;<samp>fftw3_omp</samp>&rsquo; library
rather than an &lsquo;<samp>fftw3_threads</samp>&rsquo; library (see <a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a>). You can use both <code>--enable-openmp</code> and <code>--enable-threads</code>
since they compile/install libraries with different names. By default,
the OpenMP routines are not compiled.
</li><li> <code>--with-combined-threads</code>: By default, if <code>--enable-threads</code>
is used, the threads support is compiled into a separate library that
must be linked in addition to the main FFTW library. This is so that
users of the serial library do not need to link the system threads
libraries. If <code>--with-combined-threads</code> is specified, however,
then no separate threads library is created, and threads are included
in the main FFTW library. This is mainly useful under Windows, where
no system threads library is required and inter-library dependencies
are problematic.
</li><li> <span id="index-MPI-1"></span>
<code>--enable-mpi</code>: Enables compilation and installation of the FFTW
MPI library (see <a href="Distributed_002dmemory-FFTW-with-MPI.html">Distributed-memory FFTW with MPI</a>), which provides
parallel transforms for distributed-memory systems with MPI. (By
default, the MPI routines are not compiled.) See <a href="FFTW-MPI-Installation.html">FFTW MPI Installation</a>.
</li><li> <span id="index-Fortran_002dcallable-wrappers"></span>
<code>--disable-fortran</code>: Disables inclusion of legacy-Fortran
wrapper routines (see <a href="Calling-FFTW-from-Legacy-Fortran.html">Calling FFTW from Legacy Fortran</a>) in the standard
FFTW libraries. These wrapper routines increase the library size by
only a negligible amount, so they are included by default as long as
the <code>configure</code> script finds a Fortran compiler on your system.
(To specify a particular Fortran compiler <i>foo</i>, pass
<code>F77=</code><i>foo</i> to <code>configure</code>.)
</li><li> <code>--with-g77-wrappers</code>: By default, when Fortran wrappers are
included, the wrappers employ the linking conventions of the Fortran
compiler detected by the <code>configure</code> script. If this compiler is
GNU <code>g77</code>, however, then <em>two</em> versions of the wrappers are
included: one with <code>g77</code>&rsquo;s idiosyncratic convention of appending
two underscores to identifiers, and one with the more common
convention of appending only a single underscore. This way, the same
FFTW library will work with both <code>g77</code> and other Fortran
compilers, such as GNU <code>gfortran</code>. However, the converse is not
true: if you configure with a different compiler, then the
<code>g77</code>-compatible wrappers are not included. By specifying
<code>--with-g77-wrappers</code>, the <code>g77</code>-compatible wrappers are
included in addition to wrappers for whatever Fortran compiler
<code>configure</code> finds.
<span id="index-g77"></span>
</li><li> <code>--with-slow-timer</code>: Disables the use of hardware cycle counters,
and falls back on <code>gettimeofday</code> or <code>clock</code>. This greatly
worsens performance, and should generally not be used (unless you don&rsquo;t
have a cycle counter but still really want an optimized plan regardless
of the time). See <a href="Cycle-Counters.html">Cycle Counters</a>.
</li><li> <code>--enable-sse</code> (single precision),
<code>--enable-sse2</code> (single, double),
<code>--enable-avx</code> (single, double),
<code>--enable-avx2</code> (single, double),
<code>--enable-avx512</code> (single, double),
<code>--enable-avx-128-fma</code>,
<code>--enable-kcvi</code> (single),
<code>--enable-altivec</code> (single),
<code>--enable-vsx</code> (single, double),
<code>--enable-neon</code> (single, double on aarch64),
<code>--enable-generic-simd128</code>,
and
<code>--enable-generic-simd256</code>:
<p>Enable various SIMD instruction sets. You need compiler that supports
the given SIMD extensions, but FFTW will try to detect at runtime
whether the CPU supports these extensions. That is, you can compile
with<code>--enable-avx</code> and the code will still run on a CPU without AVX
support.
</p>
<ul class="no-bullet">
<li>- These options require a compiler supporting SIMD extensions, and
compiler support is always a bit flaky: see the FFTW FAQ for a list of
compiler versions that have problems compiling FFTW.
</li><li>- Because of the large variety of ARM processors and ABIs, FFTW
does not attempt to guess the correct <code>gcc</code> flags for generating
NEON code. In general, you will have to provide them on the command line.
This command line is known to have worked at least once:
<div class="example">
<pre class="example">./configure --with-slow-timer --host=arm-linux-gnueabi \
--enable-single --enable-neon \
&quot;CC=arm-linux-gnueabi-gcc -march=armv7-a -mfloat-abi=softfp&quot;
</pre></div>
</li></ul>
</li></ul>
<span id="index-compiler-2"></span>
<p>To force <code>configure</code> to use a particular C compiler <i>foo</i>
(instead of the default, usually <code>gcc</code>), pass <code>CC=</code><i>foo</i> to the
<code>configure</code> script; you may also need to set the flags via the variable
<code>CFLAGS</code> as described above.
<span id="index-compiler-flags-1"></span>
</p>
<hr>
<div class="header">
<p>
Next: <a href="Installation-on-non_002dUnix-systems.html" accesskey="n" rel="next">Installation on non-Unix systems</a>, Previous: <a href="Installation-and-Customization.html" accesskey="p" rel="prev">Installation and Customization</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

118
fftw-3.3.10/doc/html/Installation-on-non_002dUnix-systems.html Normal file
View File

@@ -0,0 +1,118 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Installation on non-Unix systems (FFTW 3.3.10)</title>
<meta name="description" content="Installation on non-Unix systems (FFTW 3.3.10)">
<meta name="keywords" content="Installation on non-Unix systems (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Installation-and-Customization.html" rel="up" title="Installation and Customization">
<link href="Cycle-Counters.html" rel="next" title="Cycle Counters">
<link href="Installation-on-Unix.html" rel="prev" title="Installation on Unix">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Installation-on-non_002dUnix-systems"></span><div class="header">
<p>
Next: <a href="Cycle-Counters.html" accesskey="n" rel="next">Cycle Counters</a>, Previous: <a href="Installation-on-Unix.html" accesskey="p" rel="prev">Installation on Unix</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Installation-on-non_002dUnix-systems-1"></span><h3 class="section">10.2 Installation on non-Unix systems</h3>
<p>It should be relatively straightforward to compile FFTW even on non-Unix
systems lacking the niceties of a <code>configure</code> script. Basically,
you need to edit the <code>config.h</code> header (copy it from
<code>config.h.in</code>) to <code>#define</code> the various options and compiler
characteristics, and then compile all the &lsquo;<samp>.c</samp>&rsquo; files in the
relevant directories.
</p>
<p>The <code>config.h</code> header contains about 100 options to set, each one
initially an <code>#undef</code>, each documented with a comment, and most of
them fairly obvious. For most of the options, you should simply
<code>#define</code> them to <code>1</code> if they are applicable, although a few
options require a particular value (e.g. <code>SIZEOF_LONG_LONG</code> should
be defined to the size of the <code>long long</code> type, in bytes, or zero
if it is not supported). We will likely post some sample
<code>config.h</code> files for various operating systems and compilers for
you to use (at least as a starting point). Please let us know if you
have to hand-create a configuration file (and/or a pre-compiled binary)
that you want to share.
</p>
<p>To create the FFTW library, you will then need to compile all of the
&lsquo;<samp>.c</samp>&rsquo; files in the <code>kernel</code>, <code>dft</code>, <code>dft/scalar</code>,
<code>dft/scalar/codelets</code>, <code>rdft</code>, <code>rdft/scalar</code>,
<code>rdft/scalar/r2cf</code>, <code>rdft/scalar/r2cb</code>,
<code>rdft/scalar/r2r</code>, <code>reodft</code>, and <code>api</code> directories.
If you are compiling with SIMD support (e.g. you defined
<code>HAVE_SSE2</code> in <code>config.h</code>), then you also need to compile
the <code>.c</code> files in the <code>simd-support</code>,
<code>{dft,rdft}/simd</code>, <code>{dft,rdft}/simd/*</code> directories.
</p>
<p>Once these files are all compiled, link them into a library, or a shared
library, or directly into your program.
</p>
<p>To compile the FFTW test program, additionally compile the code in the
<code>libbench2/</code> directory, and link it into a library. Then compile
the code in the <code>tests/</code> directory and link it to the
<code>libbench2</code> and FFTW libraries. To compile the <code>fftw-wisdom</code>
(command-line) tool (see <a href="Wisdom-Utilities.html">Wisdom Utilities</a>), compile
<code>tools/fftw-wisdom.c</code> and link it to the <code>libbench2</code> and FFTW
libraries
</p>
<hr>
<div class="header">
<p>
Next: <a href="Cycle-Counters.html" accesskey="n" rel="next">Cycle Counters</a>, Previous: <a href="Installation-on-Unix.html" accesskey="p" rel="prev">Installation on Unix</a>, Up: <a href="Installation-and-Customization.html" accesskey="u" rel="up">Installation and Customization</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

95
fftw-3.3.10/doc/html/Interleaved-and-split-arrays.html Normal file
View File

@@ -0,0 +1,95 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Interleaved and split arrays (FFTW 3.3.10)</title>
<meta name="description" content="Interleaved and split arrays (FFTW 3.3.10)">
<meta name="keywords" content="Interleaved and split arrays (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Guru-Interface.html" rel="up" title="Guru Interface">
<link href="Guru-vector-and-transform-sizes.html" rel="next" title="Guru vector and transform sizes">
<link href="Guru-Interface.html" rel="prev" title="Guru Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Interleaved-and-split-arrays"></span><div class="header">
<p>
Next: <a href="Guru-vector-and-transform-sizes.html" accesskey="n" rel="next">Guru vector and transform sizes</a>, Previous: <a href="Guru-Interface.html" accesskey="p" rel="prev">Guru Interface</a>, Up: <a href="Guru-Interface.html" accesskey="u" rel="up">Guru Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Interleaved-and-split-arrays-1"></span><h4 class="subsection">4.5.1 Interleaved and split arrays</h4>
<p>The guru interface supports two representations of complex numbers,
which we call the interleaved and the split format.
</p>
<p>The <em>interleaved</em> format is the same one used by the basic and
advanced interfaces, and it is documented in <a href="Complex-numbers.html">Complex numbers</a>.
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.
<span id="index-interleaved-format"></span>
</p>
<p>The <em>split</em> format allows separate pointers to the real and
imaginary parts of a complex array.
<span id="index-split-format"></span>
</p>
<p>Technically, the interleaved format is redundant, because you can
always express an interleaved array in terms of a split array with
appropriate pointers and strides. On the other hand, the interleaved
format is simpler to use, and it is common in practice. Hence, FFTW
supports it as a special case.
</p>
</body>
</html>

213
fftw-3.3.10/doc/html/Introduction.html Normal file
View File

@@ -0,0 +1,213 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Introduction (FFTW 3.3.10)</title>
<meta name="description" content="Introduction (FFTW 3.3.10)">
<meta name="keywords" content="Introduction (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Tutorial.html" rel="next" title="Tutorial">
<link href="index.html" rel="prev" title="Top">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Introduction"></span><div class="header">
<p>
Next: <a href="Tutorial.html" accesskey="n" rel="next">Tutorial</a>, Previous: <a href="index.html" accesskey="p" rel="prev">Top</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Introduction-1"></span><h2 class="chapter">1 Introduction</h2>
<p>This manual documents version 3.3.10 of FFTW, the
<em>Fastest Fourier Transform in the West</em>. FFTW is a comprehensive
collection of fast C routines for computing the discrete Fourier
transform (DFT) and various special cases thereof.
<span id="index-discrete-Fourier-transform"></span>
<span id="index-DFT"></span>
</p><ul>
<li> FFTW computes the DFT of complex data, real data, even-
or odd-symmetric real data (these symmetric transforms are usually
known as the discrete cosine or sine transform, respectively), and the
discrete Hartley transform (DHT) of real data.
</li><li> The input data can have arbitrary length.
FFTW employs <i>O</i>(<i>n</i>&nbsp;log&nbsp;<i>n</i>)
algorithms for all lengths, including
prime numbers.
</li><li> FFTW supports arbitrary multi-dimensional data.
</li><li> FFTW supports the SSE, SSE2, AVX, AVX2, AVX512, KCVI, Altivec, VSX, and
NEON vector instruction sets.
</li><li> FFTW includes parallel (multi-threaded) transforms
for shared-memory systems.
</li><li> Starting with version 3.3, FFTW includes distributed-memory parallel
transforms using MPI.
</li></ul>
<p>We assume herein that you are familiar with the properties and uses of
the DFT that are relevant to your application. Otherwise, see
e.g. <cite>The Fast Fourier Transform and Its Applications</cite> by E. O. Brigham
(Prentice-Hall, Englewood Cliffs, NJ, 1988).
<a href="http://www.fftw.org">Our web page</a> also has links to FFT-related
information online.
<span id="index-FFTW"></span>
</p>
<p>In order to use FFTW effectively, you need to learn one basic concept
of FFTW&rsquo;s internal structure: FFTW does not use a fixed algorithm for
computing the transform, but instead it adapts the DFT algorithm to
details of the underlying hardware in order to maximize performance.
Hence, the computation of the transform is split into two phases.
First, FFTW&rsquo;s <em>planner</em> &ldquo;learns&rdquo; the fastest way to compute the
transform on your machine. The planner
<span id="index-planner"></span>
produces a data structure called a <em>plan</em> that contains this
<span id="index-plan"></span>
information. Subsequently, the plan is <em>executed</em>
<span id="index-execute"></span>
to transform the array of input data as dictated by the plan. The
plan can be reused as many times as needed. In typical
high-performance applications, many transforms of the same size are
computed and, consequently, a relatively expensive initialization of
this sort is acceptable. On the other hand, if you need a single
transform of a given size, the one-time cost of the planner becomes
significant. For this case, FFTW provides fast planners based on
heuristics or on previously computed plans.
</p>
<p>FFTW supports transforms of data with arbitrary length, rank,
multiplicity, and a general memory layout. In simple cases, however,
this generality may be unnecessary and confusing. Consequently, we
organized the interface to FFTW into three levels of increasing
generality.
</p><ul>
<li> The <em>basic interface</em> computes a single
transform of contiguous data.
</li><li> The <em>advanced interface</em> computes transforms
of multiple or strided arrays.
</li><li> The <em>guru interface</em> supports the most general data
layouts, multiplicities, and strides.
</li></ul>
<p>We expect that most users will be best served by the basic interface,
whereas the guru interface requires careful attention to the
documentation to avoid problems.
<span id="index-basic-interface"></span>
<span id="index-advanced-interface"></span>
<span id="index-guru-interface"></span>
</p>
<p>Besides the automatic performance adaptation performed by the planner,
it is also possible for advanced users to customize FFTW manually. For
example, if code space is a concern, we provide a tool that links only
the subset of FFTW needed by your application. Conversely, you may need
to extend FFTW because the standard distribution is not sufficient for
your needs. For example, the standard FFTW distribution works most
efficiently for arrays whose size can be factored into small primes
(<em>2</em>, <em>3</em>, <em>5</em>, and <em>7</em>), and otherwise it uses a
slower general-purpose routine. If you need efficient transforms of
other sizes, you can use FFTW&rsquo;s code generator, which produces fast C
programs (&ldquo;codelets&rdquo;) for any particular array size you may care
about.
<span id="index-code-generator"></span>
<span id="index-codelet"></span>
For example, if you need transforms of size
513&nbsp;=&nbsp;19*3<sup>3</sup>,
you can customize FFTW to support the factor <em>19</em> efficiently.
</p>
<p>For more information regarding FFTW, see the paper, &ldquo;The Design and
Implementation of FFTW3,&rdquo; by M. Frigo and S. G. Johnson, which was an
invited paper in <cite>Proc. IEEE</cite> <b>93</b> (2), p. 216 (2005). The
code generator is described in the paper &ldquo;A fast Fourier transform
compiler&rdquo;,
<span id="index-compiler"></span>
by M. Frigo, in the <cite>Proceedings of the 1999 ACM SIGPLAN Conference
on Programming Language Design and Implementation (PLDI), Atlanta,
Georgia, May 1999</cite>. These papers, along with the latest version of
FFTW, the FAQ, benchmarks, and other links, are available at
<a href="http://www.fftw.org">the FFTW home page</a>.
</p>
<p>The current version of FFTW incorporates many good ideas from the past
thirty years of FFT literature. In one way or another, FFTW uses the
Cooley-Tukey algorithm, the prime factor algorithm, Rader&rsquo;s algorithm
for prime sizes, and a split-radix algorithm (with a
&ldquo;conjugate-pair&rdquo; variation pointed out to us by Dan Bernstein).
FFTW&rsquo;s code generator also produces new algorithms that we do not
completely understand.
<span id="index-algorithm"></span>
The reader is referred to the cited papers for the appropriate
references.
</p>
<p>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 <a href="Tutorial.html">Tutorial</a>.
Next, <a href="Other-Important-Topics.html">Other Important Topics</a> discusses data alignment
(see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>),
the storage scheme of multi-dimensional arrays
(see <a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>), and FFTW&rsquo;s mechanism for
storing plans on disk (see <a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a>). Next,
<a href="FFTW-Reference.html">FFTW Reference</a> provides comprehensive documentation of all
FFTW&rsquo;s features. Parallel transforms are discussed in their own
chapters: <a href="Multi_002dthreaded-FFTW.html">Multi-threaded FFTW</a> and <a href="Distributed_002dmemory-FFTW-with-MPI.html">Distributed-memory FFTW with MPI</a>. Fortran programmers can also use FFTW, as described in
<a href="Calling-FFTW-from-Legacy-Fortran.html">Calling FFTW from Legacy Fortran</a> and <a href="Calling-FFTW-from-Modern-Fortran.html">Calling FFTW from Modern Fortran</a>. <a href="Installation-and-Customization.html">Installation and Customization</a> explains how to
install FFTW in your computer system and how to adapt FFTW to your
needs. License and copyright information is given in <a href="License-and-Copyright.html">License and Copyright</a>. Finally, we thank all the people who helped us in
<a href="Acknowledgments.html">Acknowledgments</a>.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Tutorial.html" accesskey="n" rel="next">Tutorial</a>, Previous: <a href="index.html" accesskey="p" rel="prev">Top</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

451
fftw-3.3.10/doc/html/Library-Index.html Normal file
View File

@@ -0,0 +1,451 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Library Index (FFTW 3.3.10)</title>
<meta name="description" content="Library Index (FFTW 3.3.10)">
<meta name="keywords" content="Library Index (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Concept-Index.html" rel="prev" title="Concept Index">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Library-Index"></span><div class="header">
<p>
Previous: <a href="Concept-Index.html" accesskey="p" rel="prev">Concept Index</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Library-Index-1"></span><h2 class="chapter">14 Library Index</h2>
<table><tr><th valign="top">Jump to: &nbsp; </th><td><a class="summary-letter" href="#Library-Index_fn_letter-C"><b>C</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-D"><b>D</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-F"><b>F</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-M"><b>M</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-P"><b>P</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-R"><b>R</b></a>
&nbsp;
</td></tr></table>
<table class="index-fn" border="0">
<tr><td></td><th align="left">Index Entry</th><td>&nbsp;</td><th align="left"> Section</th></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Library-Index_fn_letter-C">C</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html#index-c_005fassociated"><code>c_associated</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html">Wisdom String Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-C_005fDOUBLE"><code>C_DOUBLE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fDOUBLE-1"><code>C_DOUBLE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-C_005fDOUBLE_005fCOMPLEX"><code>C_DOUBLE_COMPLEX</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fDOUBLE_005fCOMPLEX-1"><code>C_DOUBLE_COMPLEX</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fFFTW_005fR2R_005fKIND"><code>C_FFTW_R2R_KIND</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fFLOAT"><code>C_FLOAT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fFLOAT_005fCOMPLEX"><code>C_FLOAT_COMPLEX</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html#index-c_005ffunloc"><code>c_funloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html">Wisdom Generic Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fFUNPTR"><code>C_FUNPTR</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-c_005ff_005fpointer"><code>c_f_pointer</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-c_005ff_005fpointer-1"><code>c_f_pointer</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html#index-c_005ff_005fpointer-2"><code>c_f_pointer</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html#index-c_005ff_005fpointer-3"><code>c_f_pointer</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html">Wisdom String Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html#index-c_005ff_005fpointer-4"><code>c_f_pointer</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html">Wisdom Generic Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-C_005fINT"><code>C_INT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fINT-1"><code>C_INT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fINTPTR_005fT"><code>C_INTPTR_T</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html#index-c_005floc"><code>c_loc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html">Wisdom Generic Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fLONG_005fDOUBLE"><code>C_LONG_DOUBLE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fLONG_005fDOUBLE_005fCOMPLEX"><code>C_LONG_DOUBLE_COMPLEX</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-C_005fPTR"><code>C_PTR</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-C_005fSIZE_005fT"><code>C_SIZE_T</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Library-Index_fn_letter-D">D</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fdestroy_005fplan"><code>dfftw_destroy_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Execution-in-Fortran.html#index-dfftw_005fexecute"><code>dfftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Execution-in-Fortran.html">FFTW Execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Execution-in-Fortran.html#index-dfftw_005fexecute_005fdft"><code>dfftw_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Execution-in-Fortran.html">FFTW Execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fexecute_005fdft-1"><code>dfftw_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fexecute_005fdft_005fr2c"><code>dfftw_execute_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-of-Fortran_003f.html#index-dfftw_005fexport_005fwisdom"><code>dfftw_export_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-of-Fortran_003f.html">Wisdom of Fortran?</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-of-Fortran_003f.html#index-dfftw_005fforget_005fwisdom"><code>dfftw_forget_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-of-Fortran_003f.html">Wisdom of Fortran?</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-of-Fortran_003f.html#index-dfftw_005fimport_005fsystem_005fwisdom"><code>dfftw_import_system_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-of-Fortran_003f.html">Wisdom of Fortran?</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-of-Fortran_003f.html#index-dfftw_005fimport_005fwisdom"><code>dfftw_import_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-of-Fortran_003f.html">Wisdom of Fortran?</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005finit_005fthreads"><code>dfftw_init_threads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fplanner_005fnthreads"><code>dfftw_planner_nthreads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fplan_005fdft_005f1d"><code>dfftw_plan_dft_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fplan_005fdft_005f3d"><code>dfftw_plan_dft_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fplan_005fdft_005fr2c_005f1d"><code>dfftw_plan_dft_r2c_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fplan_005fdft_005fr2c_005f2d"><code>dfftw_plan_dft_r2c_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran-Examples.html#index-dfftw_005fplan_005fwith_005fnthreads"><code>dfftw_plan_with_nthreads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran-Examples.html">Fortran Examples</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Library-Index_fn_letter-F">F</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-fftw_005falignment_005fof"><code>fftw_alignment_of</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005falignment_005fof-1"><code>fftw_alignment_of</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005falloc_005fcomplex"><code>fftw_alloc_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-fftw_005falloc_005fcomplex-1"><code>fftw_alloc_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Memory-Allocation.html#index-fftw_005falloc_005fcomplex-2"><code>fftw_alloc_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Memory-Allocation.html">Memory Allocation</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-fftw_005falloc_005fcomplex-3"><code>fftw_alloc_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-fftw_005falloc_005fcomplex-4"><code>fftw_alloc_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html#index-fftw_005falloc_005fcomplex-5"><code>fftw_alloc_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-fftw_005falloc_005freal"><code>fftw_alloc_real</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Memory-Allocation.html#index-fftw_005falloc_005freal-1"><code>fftw_alloc_real</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Memory-Allocation.html">Memory Allocation</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html#index-fftw_005falloc_005freal-2"><code>fftw_alloc_real</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html#index-fftw_005falloc_005freal-3"><code>fftw_alloc_real</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html">Other Multi-dimensional Real-data MPI Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005falloc_005freal-4"><code>fftw_alloc_real</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html#index-fftw_005falloc_005freal-5"><code>fftw_alloc_real</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-FFTW_005fBACKWARD"><code>FFTW_BACKWARD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-FFTW_005fBACKWARD-1"><code>FFTW_BACKWARD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-FFTW_005fBACKWARD-2"><code>FFTW_BACKWARD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005fcleanup"><code>fftw_cleanup</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Initialization.html#index-fftw_005fcleanup-1"><code>fftw_cleanup</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Initialization.html">MPI Initialization</a></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-fftw_005fcleanup_005fthreads"><code>fftw_cleanup_threads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005fcomplex"><code>fftw_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-numbers.html#index-fftw_005fcomplex-1"><code>fftw_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-numbers.html">Complex numbers</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-fftw_005fcomplex-2"><code>fftw_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005fcomplex-3"><code>fftw_complex</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005fcost"><code>fftw_cost</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fDESTROY_005fINPUT"><code>FFTW_DESTROY_INPUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html#index-FFTW_005fDESTROY_005fINPUT-1"><code>FFTW_DESTROY_INPUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Performance-Tips.html">FFTW MPI Performance Tips</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-FFTW_005fDESTROY_005fINPUT-2"><code>FFTW_DESTROY_INPUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005fdestroy_005fplan"><code>fftw_destroy_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005fdestroy_005fplan-1"><code>fftw_destroy_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html#index-fftw_005fdestroy_005fplan-2"><code>fftw_destroy_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html">Avoiding MPI Deadlocks</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-fftw_005fdestroy_005fplan-3"><code>fftw_destroy_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Discrete-Hartley-Transform.html#index-FFTW_005fDHT"><code>FFTW_DHT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Discrete-Hartley-Transform.html">The Discrete Hartley Transform</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fDHT-1"><code>FFTW_DHT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-FFTW_005fESTIMATE"><code>FFTW_ESTIMATE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-FFTW_005fESTIMATE-1"><code>FFTW_ESTIMATE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fESTIMATE-2"><code>FFTW_ESTIMATE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Cycle-Counters.html#index-FFTW_005fESTIMATE-3"><code>FFTW_ESTIMATE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Cycle-Counters.html">Cycle Counters</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005fexecute"><code>fftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005fexecute-1"><code>fftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute-2"><code>fftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html#index-fftw_005fexecute-3"><code>fftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html">Basic distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html#index-fftw_005fexecute-4"><code>fftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html">Avoiding MPI Deadlocks</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-fftw_005fexecute-5"><code>fftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Plan-execution-in-Fortran.html#index-fftw_005fexecute-6"><code>fftw_execute</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute_005fdft"><code>fftw_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html#index-fftw_005fexecute_005fdft-1"><code>fftw_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html">FFTW MPI Fortran Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-fftw_005fexecute_005fdft-2"><code>fftw_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Plan-execution-in-Fortran.html#index-fftw_005fexecute_005fdft-3"><code>fftw_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute_005fdft_005fc2r"><code>fftw_execute_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Plan-execution-in-Fortran.html#index-fftw_005fexecute_005fdft_005fc2r-1"><code>fftw_execute_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute_005fdft_005fr2c"><code>fftw_execute_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-fftw_005fexecute_005fdft_005fr2c-1"><code>fftw_execute_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="Plan-execution-in-Fortran.html#index-fftw_005fexecute_005fdft_005fr2c-2"><code>fftw_execute_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute_005fr2r"><code>fftw_execute_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Plan-execution-in-Fortran.html#index-fftw_005fexecute_005fr2r-1"><code>fftw_execute_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute_005fsplit_005fdft"><code>fftw_execute_split_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute_005fsplit_005fdft_005fc2r"><code>fftw_execute_split_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-fftw_005fexecute_005fsplit_005fdft_005fr2c"><code>fftw_execute_split_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-FFTW_005fEXHAUSTIVE"><code>FFTW_EXHAUSTIVE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fEXHAUSTIVE-1"><code>FFTW_EXHAUSTIVE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Export.html#index-fftw_005fexport_005fwisdom"><code>fftw_export_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Export.html">Wisdom Export</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html#index-fftw_005fexport_005fwisdom-1"><code>fftw_export_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html">Wisdom Generic Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Export.html#index-fftw_005fexport_005fwisdom_005fto_005ffile"><code>fftw_export_wisdom_to_file</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Export.html">Wisdom Export</a></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-fftw_005fexport_005fwisdom_005fto_005ffilename"><code>fftw_export_wisdom_to_filename</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Export.html#index-fftw_005fexport_005fwisdom_005fto_005ffilename-1"><code>fftw_export_wisdom_to_filename</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Export.html">Wisdom Export</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-File-Export_002fImport-from-Fortran.html#index-fftw_005fexport_005fwisdom_005fto_005ffilename-2"><code>fftw_export_wisdom_to_filename</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-File-Export_002fImport-from-Fortran.html">Wisdom File Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Export.html#index-fftw_005fexport_005fwisdom_005fto_005fstring"><code>fftw_export_wisdom_to_string</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Export.html">Wisdom Export</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html#index-fftw_005fexport_005fwisdom_005fto_005fstring-1"><code>fftw_export_wisdom_to_string</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html">Wisdom String Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005fflops"><code>fftw_flops</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html#index-fftw_005fflops-1"><code>fftw_flops</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html">Avoiding MPI Deadlocks</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005fflops-2"><code>fftw_flops</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-fftw_005fforget_005fwisdom"><code>fftw_forget_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Forgetting-Wisdom.html#index-fftw_005fforget_005fwisdom-1"><code>fftw_forget_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Forgetting-Wisdom.html">Forgetting Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-FFTW_005fFORWARD"><code>FFTW_FORWARD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-FFTW_005fFORWARD-1"><code>FFTW_FORWARD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-FFTW_005fFORWARD-2"><code>FFTW_FORWARD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005ffprint_005fplan"><code>fftw_fprint_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005ffree"><code>fftw_free</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-fftw_005ffree-1"><code>fftw_free</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Memory-Allocation.html#index-fftw_005ffree-2"><code>fftw_free</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Memory-Allocation.html">Memory Allocation</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html#index-FFTW_005fHC2R"><code>FFTW_HC2R</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fHC2R-1"><code>FFTW_HC2R</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-File-Export_002fImport-from-Fortran.html#index-fftw_005fimport-wisdom_005ffrom_005ffilename"><code>fftw_import wisdom_from_filename</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-File-Export_002fImport-from-Fortran.html">Wisdom File Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Caveats-in-Using-Wisdom.html#index-fftw_005fimport_005fsystem_005fwisdom"><code>fftw_import_system_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Caveats-in-Using-Wisdom.html">Caveats in Using Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Import.html#index-fftw_005fimport_005fsystem_005fwisdom-1"><code>fftw_import_system_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Import.html">Wisdom Import</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Import.html#index-fftw_005fimport_005fwisdom"><code>fftw_import_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Import.html">Wisdom Import</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html#index-fftw_005fimport_005fwisdom-1"><code>fftw_import_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Generic-Export_002fImport-from-Fortran.html">Wisdom Generic Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Import.html#index-fftw_005fimport_005fwisdom_005ffrom_005ffile"><code>fftw_import_wisdom_from_file</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Import.html">Wisdom Import</a></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-fftw_005fimport_005fwisdom_005ffrom_005ffilename"><code>fftw_import_wisdom_from_filename</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Import.html#index-fftw_005fimport_005fwisdom_005ffrom_005ffilename-1"><code>fftw_import_wisdom_from_filename</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Import.html">Wisdom Import</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-Import.html#index-fftw_005fimport_005fwisdom_005ffrom_005fstring"><code>fftw_import_wisdom_from_string</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-Import.html">Wisdom Import</a></td></tr>
<tr><td></td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html#index-fftw_005fimport_005fwisdom_005ffrom_005fstring-1"><code>fftw_import_wisdom_from_string</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Wisdom-String-Export_002fImport-from-Fortran.html">Wisdom String Export/Import from Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-fftw_005finit_005fthreads"><code>fftw_init_threads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html#index-fftw_005finit_005fthreads-1"><code>fftw_init_threads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html">Linking and Initializing MPI FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Combining-MPI-and-Threads.html#index-fftw_005finit_005fthreads-2"><code>fftw_init_threads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Initialization.html#index-fftw_005finit_005fthreads-3"><code>fftw_init_threads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Initialization.html">MPI Initialization</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-vector-and-transform-sizes.html#index-fftw_005fiodim"><code>fftw_iodim</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-vector-and-transform-sizes.html">Guru vector and transform sizes</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005fiodim-1"><code>fftw_iodim</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Fortran_002dinterface-routines.html#index-fftw_005fiodim-2"><code>fftw_iodim</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Fortran_002dinterface-routines.html">Fortran-interface routines</a></td></tr>
<tr><td></td><td valign="top"><a href="64_002dbit-Guru-Interface.html#index-fftw_005fiodim64"><code>fftw_iodim64</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="64_002dbit-Guru-Interface.html">64-bit Guru Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005fiodim64-1"><code>fftw_iodim64</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Thread-safety.html#index-fftw_005fmake_005fplanner_005fthread_005fsafe"><code>fftw_make_planner_thread_safe</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Thread-safety.html">Thread safety</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005fmalloc"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html#index-fftw_005fmalloc-1"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a></td></tr>
<tr><td></td><td valign="top"><a href="Dynamic-Arrays-in-C.html#index-fftw_005fmalloc-2"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Dynamic-Arrays-in-C.html">Dynamic Arrays in C</a></td></tr>
<tr><td></td><td valign="top"><a href="Memory-Allocation.html#index-fftw_005fmalloc-3"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Memory-Allocation.html">Memory Allocation</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-fftw_005fmalloc-4"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-fftw_005fmalloc-5"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-fftw_005fmalloc-6"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005fmalloc-7"><code>fftw_malloc</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-FFTW_005fMEASURE"><code>FFTW_MEASURE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-FFTW_005fMEASURE-1"><code>FFTW_MEASURE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fMEASURE-2"><code>FFTW_MEASURE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html#index-FFTW_005fMEASURE-3"><code>FFTW_MEASURE</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html">An improved replacement for MPI_Alltoall</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Wisdom.html#index-fftw_005fmpi_005fbroadcast_005fwisdom"><code>fftw_mpi_broadcast_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Wisdom-Communication.html#index-fftw_005fmpi_005fbroadcast_005fwisdom-1"><code>fftw_mpi_broadcast_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Wisdom-Communication.html">MPI Wisdom Communication</a></td></tr>
<tr><td></td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html#index-fftw_005fmpi_005fcleanup"><code>fftw_mpi_cleanup</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html">Linking and Initializing MPI FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Initialization.html#index-fftw_005fmpi_005fcleanup-1"><code>fftw_mpi_cleanup</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Initialization.html">MPI Initialization</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-FFTW_005fMPI_005fDEFAULT_005fBLOCK"><code>FFTW_MPI_DEFAULT_BLOCK</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-distributed_002dtranspose-interface.html#index-FFTW_005fMPI_005fDEFAULT_005fBLOCK-1"><code>FFTW_MPI_DEFAULT_BLOCK</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-distributed_002dtranspose-interface.html">Advanced distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-FFTW_005fMPI_005fDEFAULT_005fBLOCK-2"><code>FFTW_MPI_DEFAULT_BLOCK</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-fftw_005fmpi_005fexecute_005fdft"><code>fftw_mpi_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html#index-fftw_005fmpi_005fexecute_005fdft-1"><code>fftw_mpi_execute_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Fortran-Interface.html">FFTW MPI Fortran Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-fftw_005fmpi_005fexecute_005fdft_005fc2r"><code>fftw_mpi_execute_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-fftw_005fmpi_005fexecute_005fdft_005fr2c"><code>fftw_mpi_execute_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-MPI-Plans.html#index-fftw_005fmpi_005fexecute_005fr2r"><code>fftw_mpi_execute_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-MPI-Plans.html">Using MPI Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fexecute_005fr2r-1"><code>fftw_mpi_execute_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Wisdom.html#index-fftw_005fmpi_005fgather_005fwisdom"><code>fftw_mpi_gather_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Wisdom-Communication.html#index-fftw_005fmpi_005fgather_005fwisdom-1"><code>fftw_mpi_gather_wisdom</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Wisdom-Communication.html">MPI Wisdom Communication</a></td></tr>
<tr><td></td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html#index-fftw_005fmpi_005finit"><code>fftw_mpi_init</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Linking-and-Initializing-MPI-FFTW.html">Linking and Initializing MPI FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-fftw_005fmpi_005finit-1"><code>fftw_mpi_init</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-MPI-Wisdom.html#index-fftw_005fmpi_005finit-2"><code>fftw_mpi_init</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a></td></tr>
<tr><td></td><td valign="top"><a href="Combining-MPI-and-Threads.html#index-fftw_005fmpi_005finit-3"><code>fftw_mpi_init</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Initialization.html#index-fftw_005fmpi_005finit-4"><code>fftw_mpi_init</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Initialization.html">MPI Initialization</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize"><code>fftw_mpi_local_size</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002ddimensional-distributions.html#index-fftw_005fmpi_005flocal_005fsize_005f1d"><code>fftw_mpi_local_size_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002ddimensional-distributions.html">One-dimensional distributions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005f1d-1"><code>fftw_mpi_local_size_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-fftw_005fmpi_005flocal_005fsize_005f2d"><code>fftw_mpi_local_size_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-fftw_005fmpi_005flocal_005fsize_005f2d-1"><code>fftw_mpi_local_size_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005f2d-2"><code>fftw_mpi_local_size_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html#index-fftw_005fmpi_005flocal_005fsize_005f2d_005ftransposed"><code>fftw_mpi_local_size_2d_transposed</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html">Basic distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005f2d_005ftransposed-1"><code>fftw_mpi_local_size_2d_transposed</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005f3d"><code>fftw_mpi_local_size_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Transposed-distributions.html#index-fftw_005fmpi_005flocal_005fsize_005f3d_005ftransposed"><code>fftw_mpi_local_size_3d_transposed</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Transposed-distributions.html">Transposed distributions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005f3d_005ftransposed-1"><code>fftw_mpi_local_size_3d_transposed</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html#index-fftw_005fmpi_005flocal_005fsize_005fmany"><code>fftw_mpi_local_size_many</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005fmany-1"><code>fftw_mpi_local_size_many</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005fmany_005f1d"><code>fftw_mpi_local_size_many_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-distributed_002dtranspose-interface.html#index-fftw_005fmpi_005flocal_005fsize_005fmany_005ftransposed"><code>fftw_mpi_local_size_many_transposed</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-distributed_002dtranspose-interface.html">Advanced distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005fmany_005ftransposed-1"><code>fftw_mpi_local_size_many_transposed</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-fftw_005fmpi_005flocal_005fsize_005ftransposed"><code>fftw_mpi_local_size_transposed</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft"><code>fftw_mpi_plan_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005f1d"><code>fftw_mpi_plan_dft_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-fftw_005fmpi_005fplan_005fdft_005f2d"><code>fftw_mpi_plan_dft_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005f2d-1"><code>fftw_mpi_plan_dft_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005f3d"><code>fftw_mpi_plan_dft_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fc2r"><code>fftw_mpi_plan_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fc2r_005f2d"><code>fftw_mpi_plan_dft_c2r_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fc2r_005f2d-1"><code>fftw_mpi_plan_dft_c2r_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fc2r_005f3d"><code>fftw_mpi_plan_dft_c2r_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fr2c"><code>fftw_mpi_plan_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fr2c_005f2d"><code>fftw_mpi_plan_dft_r2c_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fr2c_005f2d-1"><code>fftw_mpi_plan_dft_r2c_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fdft_005fr2c_005f3d"><code>fftw_mpi_plan_dft_r2c_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fmany_005fdft"><code>fftw_mpi_plan_many_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fmany_005fdft_005fc2r"><code>fftw_mpi_plan_many_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fmany_005fdft_005fr2c"><code>fftw_mpi_plan_many_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-distributed_002dtranspose-interface.html#index-fftw_005fmpi_005fplan_005fmany_005ftranspose"><code>fftw_mpi_plan_many_transpose</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-distributed_002dtranspose-interface.html">Advanced distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005fmany_005ftranspose-1"><code>fftw_mpi_plan_many_transpose</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html#index-fftw_005fmpi_005fplan_005ftranspose"><code>fftw_mpi_plan_transpose</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html">Basic distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-fftw_005fmpi_005fplan_005ftranspose-1"><code>fftw_mpi_plan_transpose</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002ddimensional-distributions.html#index-FFTW_005fMPI_005fSCRAMBLED_005fIN"><code>FFTW_MPI_SCRAMBLED_IN</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002ddimensional-distributions.html">One-dimensional distributions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-FFTW_005fMPI_005fSCRAMBLED_005fIN-1"><code>FFTW_MPI_SCRAMBLED_IN</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-FFTW_005fMPI_005fSCRAMBLED_005fIN-2"><code>FFTW_MPI_SCRAMBLED_IN</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002ddimensional-distributions.html#index-FFTW_005fMPI_005fSCRAMBLED_005fOUT"><code>FFTW_MPI_SCRAMBLED_OUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002ddimensional-distributions.html">One-dimensional distributions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Data-Distribution-Functions.html#index-FFTW_005fMPI_005fSCRAMBLED_005fOUT-1"><code>FFTW_MPI_SCRAMBLED_OUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Data-Distribution-Functions.html">MPI Data Distribution Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-FFTW_005fMPI_005fSCRAMBLED_005fOUT-2"><code>FFTW_MPI_SCRAMBLED_OUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Transposed-distributions.html#index-FFTW_005fMPI_005fTRANSPOSED_005fIN"><code>FFTW_MPI_TRANSPOSED_IN</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Transposed-distributions.html">Transposed distributions</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html#index-FFTW_005fMPI_005fTRANSPOSED_005fIN-1"><code>FFTW_MPI_TRANSPOSED_IN</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html">Basic distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-FFTW_005fMPI_005fTRANSPOSED_005fIN-2"><code>FFTW_MPI_TRANSPOSED_IN</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Transposed-distributions.html#index-FFTW_005fMPI_005fTRANSPOSED_005fOUT"><code>FFTW_MPI_TRANSPOSED_OUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Transposed-distributions.html">Transposed distributions</a></td></tr>
<tr><td></td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html#index-FFTW_005fMPI_005fTRANSPOSED_005fOUT-1"><code>FFTW_MPI_TRANSPOSED_OUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Basic-distributed_002dtranspose-interface.html">Basic distributed-transpose interface</a></td></tr>
<tr><td></td><td valign="top"><a href="MPI-Plan-Creation.html#index-FFTW_005fMPI_005fTRANSPOSED_005fOUT-2"><code>FFTW_MPI_TRANSPOSED_OUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="MPI-Plan-Creation.html">MPI Plan Creation</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fNO_005fTIMELIMIT"><code>FFTW_NO_TIMELIMIT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-FFTW_005fPATIENT"><code>FFTW_PATIENT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html#index-FFTW_005fPATIENT-1"><code>FFTW_PATIENT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fPATIENT-2"><code>FFTW_PATIENT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="How-Many-Threads-to-Use_003f.html#index-FFTW_005fPATIENT-3"><code>FFTW_PATIENT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="How-Many-Threads-to-Use_003f.html">How Many Threads to Use?</a></td></tr>
<tr><td></td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html#index-FFTW_005fPATIENT-4"><code>FFTW_PATIENT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html">An improved replacement for MPI_Alltoall</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005fplan"><code>fftw_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005fplan-1"><code>fftw_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005fplan-2"><code>fftw_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-fftw_005fplanner_005fnthreads"><code>fftw_planner_nthreads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html#index-fftw_005fplan_005fdft"><code>fftw_plan_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-fftw_005fplan_005fdft-1"><code>fftw_plan_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html#index-fftw_005fplan_005fdft_005f1d"><code>fftw_plan_dft_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-One_002dDimensional-DFTs.html">Complex One-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-fftw_005fplan_005fdft_005f1d-1"><code>fftw_plan_dft_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html#index-fftw_005fplan_005fdft_005f2d"><code>fftw_plan_dft_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-fftw_005fplan_005fdft_005f2d-1"><code>fftw_plan_dft_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Overview-of-Fortran-interface.html#index-fftw_005fplan_005fdft_005f2d-2"><code>fftw_plan_dft_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Overview-of-Fortran-interface.html">Overview of Fortran interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html#index-fftw_005fplan_005fdft_005f3d"><code>fftw_plan_dft_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Complex-DFTs.html#index-fftw_005fplan_005fdft_005f3d-1"><code>fftw_plan_dft_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Complex-DFTs.html">Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-fftw_005fplan_005fdft_005f3d-2"><code>fftw_plan_dft_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fc2r"><code>fftw_plan_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-fftw_005fplan_005fdft_005fc2r_005f1d"><code>fftw_plan_dft_c2r_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fc2r_005f1d-1"><code>fftw_plan_dft_c2r_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fc2r_005f2d"><code>fftw_plan_dft_c2r_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fc2r_005f3d"><code>fftw_plan_dft_c2r_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html#index-fftw_005fplan_005fdft_005fr2c"><code>fftw_plan_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fr2c-1"><code>fftw_plan_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-fftw_005fplan_005fdft_005fr2c_005f1d"><code>fftw_plan_dft_r2c_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fr2c_005f1d-1"><code>fftw_plan_dft_r2c_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html#index-fftw_005fplan_005fdft_005fr2c_005f2d"><code>fftw_plan_dft_r2c_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fr2c_005f2d-1"><code>fftw_plan_dft_r2c_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html#index-fftw_005fplan_005fdft_005fr2c_005f3d"><code>fftw_plan_dft_r2c_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002ddata-DFTs.html#index-fftw_005fplan_005fdft_005fr2c_005f3d-1"><code>fftw_plan_dft_r2c_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002ddata-DFTs.html">Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Reversing-array-dimensions.html#index-fftw_005fplan_005fdft_005fr2c_005f3d-2"><code>fftw_plan_dft_r2c_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Reversing-array-dimensions.html">Reversing array dimensions</a></td></tr>
<tr><td></td><td valign="top"><a href="64_002dbit-Guru-Interface.html#index-fftw_005fplan_005fguru64_005fdft"><code>fftw_plan_guru64_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="64_002dbit-Guru-Interface.html">64-bit Guru Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Complex-DFTs.html#index-fftw_005fplan_005fguru_005fdft"><code>fftw_plan_guru_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Complex-DFTs.html">Guru Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html#index-fftw_005fplan_005fguru_005fdft_005fc2r"><code>fftw_plan_guru_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html">Guru Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html#index-fftw_005fplan_005fguru_005fdft_005fr2c"><code>fftw_plan_guru_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html">Guru Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002dto_002dreal-Transforms.html#index-fftw_005fplan_005fguru_005fr2r"><code>fftw_plan_guru_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002dto_002dreal-Transforms.html">Guru Real-to-real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Complex-DFTs.html#index-fftw_005fplan_005fguru_005fsplit_005fdft"><code>fftw_plan_guru_split_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Complex-DFTs.html">Guru Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html#index-fftw_005fplan_005fguru_005fsplit_005fdft_005fc2r"><code>fftw_plan_guru_split_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html">Guru Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html#index-fftw_005fplan_005fguru_005fsplit_005fdft_005fr2c"><code>fftw_plan_guru_split_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Guru-Real_002ddata-DFTs.html">Guru Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Complex-DFTs.html#index-fftw_005fplan_005fmany_005fdft"><code>fftw_plan_many_dft</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Complex-DFTs.html">Advanced Complex DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Real_002ddata-DFTs.html#index-fftw_005fplan_005fmany_005fdft_005fc2r"><code>fftw_plan_many_dft_c2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Real_002ddata-DFTs.html">Advanced Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Real_002ddata-DFTs.html#index-fftw_005fplan_005fmany_005fdft_005fr2c"><code>fftw_plan_many_dft_r2c</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Real_002ddata-DFTs.html">Advanced Real-data DFTs</a></td></tr>
<tr><td></td><td valign="top"><a href="Advanced-Real_002dto_002dreal-Transforms.html#index-fftw_005fplan_005fmany_005fr2r"><code>fftw_plan_many_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Advanced-Real_002dto_002dreal-Transforms.html">Advanced Real-to-real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="More-DFTs-of-Real-Data.html#index-fftw_005fplan_005fr2r"><code>fftw_plan_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-fftw_005fplan_005fr2r-1"><code>fftw_plan_r2r</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="More-DFTs-of-Real-Data.html#index-fftw_005fplan_005fr2r_005f1d"><code>fftw_plan_r2r_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-fftw_005fplan_005fr2r_005f1d-1"><code>fftw_plan_r2r_1d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="More-DFTs-of-Real-Data.html#index-fftw_005fplan_005fr2r_005f2d"><code>fftw_plan_r2r_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-fftw_005fplan_005fr2r_005f2d-1"><code>fftw_plan_r2r_2d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="More-DFTs-of-Real-Data.html#index-fftw_005fplan_005fr2r_005f3d"><code>fftw_plan_r2r_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-fftw_005fplan_005fr2r_005f3d-1"><code>fftw_plan_r2r_3d</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-fftw_005fplan_005fwith_005fnthreads"><code>fftw_plan_with_nthreads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Combining-MPI-and-Threads.html#index-fftw_005fplan_005fwith_005fnthreads-1"><code>fftw_plan_with_nthreads</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a></td></tr>
<tr><td></td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html#index-FFTW_005fPRESERVE_005fINPUT"><code>FFTW_PRESERVE_INPUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fPRESERVE_005fINPUT-1"><code>FFTW_PRESERVE_INPUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Using-Plans.html#index-fftw_005fprint_005fplan"><code>fftw_print_plan</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Using-Plans.html">Using Plans</a></td></tr>
<tr><td></td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html#index-FFTW_005fR2HC"><code>FFTW_R2HC</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fR2HC-1"><code>FFTW_R2HC</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="More-DFTs-of-Real-Data.html#index-fftw_005fr2r_005fkind"><code>fftw_r2r_kind</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html#index-fftw_005fr2r_005fkind-1"><code>fftw_r2r_kind</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html">Other Multi-dimensional Real-data MPI Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-fftw_005fr2r_005fkind-2"><code>fftw_r2r_kind</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fREDFT00"><code>FFTW_REDFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html#index-FFTW_005fREDFT00-1"><code>FFTW_REDFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transforms.html">Real-to-Real Transforms</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fREDFT00-2"><code>FFTW_REDFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fREDFT01"><code>FFTW_REDFT01</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fREDFT01-1"><code>FFTW_REDFT01</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fREDFT10"><code>FFTW_REDFT10</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fREDFT10-1"><code>FFTW_REDFT10</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fREDFT11"><code>FFTW_REDFT11</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fREDFT11-1"><code>FFTW_REDFT11</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fRODFT00"><code>FFTW_RODFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fRODFT00-1"><code>FFTW_RODFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fRODFT01"><code>FFTW_RODFT01</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fRODFT01-1"><code>FFTW_RODFT01</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fRODFT10"><code>FFTW_RODFT10</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fRODFT10-1"><code>FFTW_RODFT10</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html#index-FFTW_005fRODFT11"><code>FFTW_RODFT11</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html">Real even/odd DFTs (cosine/sine transforms)</a></td></tr>
<tr><td></td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html#index-FFTW_005fRODFT11-1"><code>FFTW_RODFT11</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-fftw_005fset_005ftimelimit"><code>fftw_set_timelimit</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html#index-fftw_005fthreads_005fset_005fcallback"><code>fftw_threads_set_callback</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Usage-of-Multi_002dthreaded-FFTW.html">Usage of Multi-threaded FFTW</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html#index-FFTW_005fTRANSPOSED_005fIN"><code>FFTW_TRANSPOSED_IN</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html#index-FFTW_005fTRANSPOSED_005fOUT"><code>FFTW_TRANSPOSED_OUT</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fUNALIGNED"><code>FFTW_UNALIGNED</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td></td><td valign="top"><a href="New_002darray-Execute-Functions.html#index-FFTW_005fUNALIGNED-1"><code>FFTW_UNALIGNED</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a></td></tr>
<tr><td></td><td valign="top"><a href="Plan-execution-in-Fortran.html#index-FFTW_005fUNALIGNED-2"><code>FFTW_UNALIGNED</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Execution-in-Fortran.html#index-FFTW_005fUNALIGNED-3"><code>FFTW_UNALIGNED</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Execution-in-Fortran.html">FFTW Execution in Fortran</a></td></tr>
<tr><td></td><td valign="top"><a href="Planner-Flags.html#index-FFTW_005fWISDOM_005fONLY"><code>FFTW_WISDOM_ONLY</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Planner-Flags.html">Planner Flags</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Library-Index_fn_letter-M">M</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html#index-MPI_005fAlltoall"><code>MPI_Alltoall</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="An-improved-replacement-for-MPI_005fAlltoall.html">An improved replacement for MPI_Alltoall</a></td></tr>
<tr><td></td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html#index-MPI_005fBarrier"><code>MPI_Barrier</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Avoiding-MPI-Deadlocks.html">Avoiding MPI Deadlocks</a></td></tr>
<tr><td></td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html#index-MPI_005fCOMM_005fWORLD"><code>MPI_COMM_WORLD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="Distributed_002dmemory-FFTW-with-MPI.html">Distributed-memory FFTW with MPI</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-MPI_005fCOMM_005fWORLD-1"><code>MPI_COMM_WORLD</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-MPI_005fInit"><code>MPI_Init</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Library-Index_fn_letter-P">P</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="64_002dbit-Guru-Interface.html#index-ptrdiff_005ft"><code>ptrdiff_t</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="64_002dbit-Guru-Interface.html">64-bit Guru Interface</a></td></tr>
<tr><td></td><td valign="top"><a href="2d-MPI-example.html#index-ptrdiff_005ft-1"><code>ptrdiff_t</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="2d-MPI-example.html">2d MPI example</a></td></tr>
<tr><td></td><td valign="top"><a href="FFTW-Fortran-type-reference.html#index-ptrdiff_005ft-2"><code>ptrdiff_t</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
<tr><th id="Library-Index_fn_letter-R">R</th><td></td><td></td></tr>
<tr><td></td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html#index-R2HC"><code>R2HC</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="The-1d-Real_002ddata-DFT.html">The 1d Real-data DFT</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-REDFT00"><code>REDFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-REDFT00-1"><code>REDFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-REDFT01"><code>REDFT01</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-REDFT10"><code>REDFT10</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html#index-REDFT11"><code>REDFT11</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html">1d Real-even DFTs (DCTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-RODFT00"><code>RODFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-RODFT00-1"><code>RODFT00</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-RODFT01"><code>RODFT01</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-RODFT10"><code>RODFT10</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td></td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html#index-RODFT11"><code>RODFT11</code></a>:</td><td>&nbsp;</td><td valign="top"><a href="1d-Real_002dodd-DFTs-_0028DSTs_0029.html">1d Real-odd DFTs (DSTs)</a></td></tr>
<tr><td colspan="4"> <hr></td></tr>
</table>
<table><tr><th valign="top">Jump to: &nbsp; </th><td><a class="summary-letter" href="#Library-Index_fn_letter-C"><b>C</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-D"><b>D</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-F"><b>F</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-M"><b>M</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-P"><b>P</b></a>
&nbsp;
<a class="summary-letter" href="#Library-Index_fn_letter-R"><b>R</b></a>
&nbsp;
</td></tr></table>
<hr>
<div class="header">
<p>
Previous: <a href="Concept-Index.html" accesskey="p" rel="prev">Concept Index</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

113
fftw-3.3.10/doc/html/License-and-Copyright.html Normal file
View File

@@ -0,0 +1,113 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>License and Copyright (FFTW 3.3.10)</title>
<meta name="description" content="License and Copyright (FFTW 3.3.10)">
<meta name="keywords" content="License and Copyright (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Concept-Index.html" rel="next" title="Concept Index">
<link href="Acknowledgments.html" rel="prev" title="Acknowledgments">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="License-and-Copyright"></span><div class="header">
<p>
Next: <a href="Concept-Index.html" accesskey="n" rel="next">Concept Index</a>, Previous: <a href="Acknowledgments.html" accesskey="p" rel="prev">Acknowledgments</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="License-and-Copyright-1"></span><h2 class="chapter">12 License and Copyright</h2>
<p>FFTW is Copyright &copy; 2003, 2007-11 Matteo Frigo, Copyright
&copy; 2003, 2007-11 Massachusetts Institute of Technology.
</p>
<p>FFTW is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
</p>
<p>This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
</p>
<p>You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA You can also
find the <a href="http://www.gnu.org/licenses/gpl-2.0.html">GPL on the GNU
web site</a>.
</p>
<p>In addition, we kindly ask you to acknowledge FFTW and its authors in
any program or publication in which you use FFTW. (You are not
<em>required</em> to do so; it is up to your common sense to decide
whether you want to comply with this request or not.) For general
publications, we suggest referencing: Matteo Frigo and Steven
G. Johnson, &ldquo;The design and implementation of FFTW3,&rdquo;
<i>Proc. IEEE</i> <b>93</b> (2), 216&ndash;231 (2005).
</p>
<p>Non-free versions of FFTW are available under terms different from those
of the General Public License. (e.g. they do not require you to
accompany any object code using FFTW with the corresponding source
code.) For these alternative terms you must purchase a license from MIT&rsquo;s
Technology Licensing Office. Users interested in such a license should
contact us (<a href="mailto:fftw@fftw.org">fftw@fftw.org</a>) for more information.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Concept-Index.html" accesskey="n" rel="next">Concept Index</a>, Previous: <a href="Acknowledgments.html" accesskey="p" rel="prev">Acknowledgments</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

108
fftw-3.3.10/doc/html/Linking-and-Initializing-MPI-FFTW.html Normal file
View File

@@ -0,0 +1,108 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Linking and Initializing MPI FFTW (FFTW 3.3.10)</title>
<meta name="description" content="Linking and Initializing MPI FFTW (FFTW 3.3.10)">
<meta name="keywords" content="Linking and Initializing MPI FFTW (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="2d-MPI-example.html" rel="next" title="2d MPI example">
<link href="FFTW-MPI-Installation.html" rel="prev" title="FFTW MPI Installation">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Linking-and-Initializing-MPI-FFTW"></span><div class="header">
<p>
Next: <a href="2d-MPI-example.html" accesskey="n" rel="next">2d MPI example</a>, Previous: <a href="FFTW-MPI-Installation.html" accesskey="p" rel="prev">FFTW MPI Installation</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Linking-and-Initializing-MPI-FFTW-1"></span><h3 class="section">6.2 Linking and Initializing MPI FFTW</h3>
<p>Programs using the MPI FFTW routines should be linked with
<code>-lfftw3_mpi -lfftw3 -lm</code> on Unix in double precision,
<code>-lfftw3f_mpi -lfftw3f -lm</code> in single precision, and so on
(see <a href="Precision.html">Precision</a>). You will also need to link with whatever library
is responsible for MPI on your system; in most MPI implementations,
there is a special compiler alias named <code>mpicc</code> to compile and
link MPI code.
<span id="index-mpicc-1"></span>
<span id="index-linking-on-Unix-1"></span>
<span id="index-precision-5"></span>
</p>
<span id="index-fftw_005finit_005fthreads-1"></span>
<p>Before calling any FFTW routines except possibly
<code>fftw_init_threads</code> (see <a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a>), but after calling
<code>MPI_Init</code>, you should call the function:
</p>
<div class="example">
<pre class="example">void fftw_mpi_init(void);
</pre></div>
<span id="index-fftw_005fmpi_005finit"></span>
<p>If, at the end of your program, you want to get rid of all memory and
other resources allocated internally by FFTW, for both the serial and
MPI routines, you can call:
</p>
<div class="example">
<pre class="example">void fftw_mpi_cleanup(void);
</pre></div>
<span id="index-fftw_005fmpi_005fcleanup"></span>
<p>which is much like the <code>fftw_cleanup()</code> function except that it
also gets rid of FFTW&rsquo;s MPI-related data. You must <em>not</em> execute
any previously created plans after calling this function.
</p>
</body>
</html>

102
fftw-3.3.10/doc/html/Load-balancing.html Normal file
View File

@@ -0,0 +1,102 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Load balancing (FFTW 3.3.10)</title>
<meta name="description" content="Load balancing (FFTW 3.3.10)">
<meta name="keywords" content="Load balancing (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="MPI-Data-Distribution.html" rel="up" title="MPI Data Distribution">
<link href="Transposed-distributions.html" rel="next" title="Transposed distributions">
<link href="Basic-and-advanced-distribution-interfaces.html" rel="prev" title="Basic and advanced distribution interfaces">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Load-balancing"></span><div class="header">
<p>
Next: <a href="Transposed-distributions.html" accesskey="n" rel="next">Transposed distributions</a>, Previous: <a href="Basic-and-advanced-distribution-interfaces.html" accesskey="p" rel="prev">Basic and advanced distribution interfaces</a>, Up: <a href="MPI-Data-Distribution.html" accesskey="u" rel="up">MPI Data Distribution</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Load-balancing-1"></span><h4 class="subsection">6.4.2 Load balancing</h4>
<span id="index-load-balancing"></span>
<p>Ideally, when you parallelize a transform over some <em>P</em>
processes, each process should end up with work that takes equal time.
Otherwise, all of the processes end up waiting on whichever process is
slowest. This goal is known as &ldquo;load balancing.&rdquo; In this section,
we describe the circumstances under which FFTW is able to load-balance
well, and in particular how you should choose your transform size in
order to load balance.
</p>
<p>Load balancing is especially difficult when you are parallelizing over
heterogeneous machines; for example, if one of your processors is a
old 486 and another is a Pentium IV, obviously you should give the
Pentium more work to do than the 486 since the latter is much slower.
FFTW does not deal with this problem, however&mdash;it assumes that your
processes run on hardware of comparable speed, and that the goal is
therefore to divide the problem as equally as possible.
</p>
<p>For a multi-dimensional complex DFT, FFTW can divide the problem
equally among the processes if: (i) the <em>first</em> dimension
<code>n0</code> is divisible by <em>P</em>; and (ii), the <em>product</em> of
the subsequent dimensions is divisible by <em>P</em>. (For the advanced
interface, where you can specify multiple simultaneous transforms via
some &ldquo;vector&rdquo; length <code>howmany</code>, a factor of <code>howmany</code> is
included in the product of the subsequent dimensions.)
</p>
<p>For a one-dimensional complex DFT, the length <code>N</code> of the data
should be divisible by <em>P</em> <em>squared</em> to be able to divide
the problem equally among the processes.
</p>
</body>
</html>

187
fftw-3.3.10/doc/html/MPI-Data-Distribution-Functions.html Normal file
View File

@@ -0,0 +1,187 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>MPI Data Distribution Functions (FFTW 3.3.10)</title>
<meta name="description" content="MPI Data Distribution Functions (FFTW 3.3.10)">
<meta name="keywords" content="MPI Data Distribution Functions (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Reference.html" rel="up" title="FFTW MPI Reference">
<link href="MPI-Plan-Creation.html" rel="next" title="MPI Plan Creation">
<link href="Using-MPI-Plans.html" rel="prev" title="Using MPI Plans">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="MPI-Data-Distribution-Functions"></span><div class="header">
<p>
Next: <a href="MPI-Plan-Creation.html" accesskey="n" rel="next">MPI Plan Creation</a>, Previous: <a href="Using-MPI-Plans.html" accesskey="p" rel="prev">Using MPI Plans</a>, Up: <a href="FFTW-MPI-Reference.html" accesskey="u" rel="up">FFTW MPI Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="MPI-Data-Distribution-Functions-1"></span><h4 class="subsection">6.12.4 MPI Data Distribution Functions</h4>
<span id="index-data-distribution-5"></span>
<p>As described above (see <a href="MPI-Data-Distribution.html">MPI Data Distribution</a>), in order to
allocate your arrays, <em>before</em> creating a plan, you must first
call one of the following routines to determine the required
allocation size and the portion of the array locally stored on a given
process. The <code>MPI_Comm</code> communicator passed here must be
equivalent to the communicator used below for plan creation.
</p>
<p>The basic interface for multidimensional transforms consists of the
functions:
</p>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f2d-2"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f3d"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f2d_005ftransposed-1"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f3d_005ftransposed-1"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005ftransposed"></span>
<div class="example">
<pre class="example">ptrdiff_t fftw_mpi_local_size_2d(ptrdiff_t n0, ptrdiff_t n1, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start);
ptrdiff_t fftw_mpi_local_size_3d(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t n2,
MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start);
ptrdiff_t fftw_mpi_local_size(int rnk, const ptrdiff_t *n, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start);
ptrdiff_t fftw_mpi_local_size_2d_transposed(ptrdiff_t n0, ptrdiff_t n1, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start,
ptrdiff_t *local_n1, ptrdiff_t *local_1_start);
ptrdiff_t fftw_mpi_local_size_3d_transposed(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t n2,
MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start,
ptrdiff_t *local_n1, ptrdiff_t *local_1_start);
ptrdiff_t fftw_mpi_local_size_transposed(int rnk, const ptrdiff_t *n, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start,
ptrdiff_t *local_n1, ptrdiff_t *local_1_start);
</pre></div>
<p>These functions return the number of elements to allocate (complex
numbers for DFT/r2c/c2r plans, real numbers for r2r plans), whereas
the <code>local_n0</code> and <code>local_0_start</code> return the portion
(<code>local_0_start</code> to <code>local_0_start + local_n0 - 1</code>) of the
first dimension of an n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
array that is stored on the local
process. See <a href="Basic-and-advanced-distribution-interfaces.html">Basic and advanced distribution interfaces</a>. For
<code>FFTW_MPI_TRANSPOSED_OUT</code> plans, the &lsquo;<samp>_transposed</samp>&rsquo; variants
are useful in order to also return the local portion of the first
dimension in the n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&hellip;&times;&nbsp;n<sub>d-1</sub>
transposed output.
See <a href="Transposed-distributions.html">Transposed distributions</a>.
The advanced interface for multidimensional transforms is:
</p>
<span id="index-advanced-interface-5"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005fmany-1"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005fmany_005ftransposed-1"></span>
<div class="example">
<pre class="example">ptrdiff_t fftw_mpi_local_size_many(int rnk, const ptrdiff_t *n, ptrdiff_t howmany,
ptrdiff_t block0, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start);
ptrdiff_t fftw_mpi_local_size_many_transposed(int rnk, const ptrdiff_t *n, ptrdiff_t howmany,
ptrdiff_t block0, ptrdiff_t block1, MPI_Comm comm,
ptrdiff_t *local_n0, ptrdiff_t *local_0_start,
ptrdiff_t *local_n1, ptrdiff_t *local_1_start);
</pre></div>
<p>These differ from the basic interface in only two ways. First, they
allow you to specify block sizes <code>block0</code> and <code>block1</code> (the
latter for the transposed output); you can pass
<code>FFTW_MPI_DEFAULT_BLOCK</code> to use FFTW&rsquo;s default block size as in
the basic interface. Second, you can pass a <code>howmany</code> parameter,
corresponding to the advanced planning interface below: this is for
transforms of contiguous <code>howmany</code>-tuples of numbers
(<code>howmany = 1</code> in the basic interface).
</p>
<p>The corresponding basic and advanced routines for one-dimensional
transforms (currently only complex DFTs) are:
</p>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f1d-1"></span>
<span id="index-fftw_005fmpi_005flocal_005fsize_005fmany_005f1d"></span>
<div class="example">
<pre class="example">ptrdiff_t fftw_mpi_local_size_1d(
ptrdiff_t n0, MPI_Comm comm, int sign, unsigned flags,
ptrdiff_t *local_ni, ptrdiff_t *local_i_start,
ptrdiff_t *local_no, ptrdiff_t *local_o_start);
ptrdiff_t fftw_mpi_local_size_many_1d(
ptrdiff_t n0, ptrdiff_t howmany,
MPI_Comm comm, int sign, unsigned flags,
ptrdiff_t *local_ni, ptrdiff_t *local_i_start,
ptrdiff_t *local_no, ptrdiff_t *local_o_start);
</pre></div>
<span id="index-FFTW_005fMPI_005fSCRAMBLED_005fOUT-1"></span>
<span id="index-FFTW_005fMPI_005fSCRAMBLED_005fIN-1"></span>
<p>As above, the return value is the number of elements to allocate
(complex numbers, for complex DFTs). The <code>local_ni</code> and
<code>local_i_start</code> arguments return the portion
(<code>local_i_start</code> to <code>local_i_start + local_ni - 1</code>) of the
1d array that is stored on this process for the transform
<em>input</em>, and <code>local_no</code> and <code>local_o_start</code> are the
corresponding quantities for the input. The <code>sign</code>
(<code>FFTW_FORWARD</code> or <code>FFTW_BACKWARD</code>) and <code>flags</code> must
match the arguments passed when creating a plan. Although the inputs
and outputs have different data distributions in general, it is
guaranteed that the <em>output</em> data distribution of an
<code>FFTW_FORWARD</code> plan will match the <em>input</em> data distribution
of an <code>FFTW_BACKWARD</code> plan and vice versa; similarly for the
<code>FFTW_MPI_SCRAMBLED_OUT</code> and <code>FFTW_MPI_SCRAMBLED_IN</code> flags.
See <a href="One_002ddimensional-distributions.html">One-dimensional distributions</a>.
</p>
<hr>
<div class="header">
<p>
Next: <a href="MPI-Plan-Creation.html" accesskey="n" rel="next">MPI Plan Creation</a>, Previous: <a href="Using-MPI-Plans.html" accesskey="p" rel="prev">Using MPI Plans</a>, Up: <a href="FFTW-MPI-Reference.html" accesskey="u" rel="up">FFTW MPI Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

139
fftw-3.3.10/doc/html/MPI-Data-Distribution.html Normal file
View File

@@ -0,0 +1,139 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>MPI Data Distribution (FFTW 3.3.10)</title>
<meta name="description" content="MPI Data Distribution (FFTW 3.3.10)">
<meta name="keywords" content="MPI Data Distribution (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="Basic-and-advanced-distribution-interfaces.html" rel="next" title="Basic and advanced distribution interfaces">
<link href="2d-MPI-example.html" rel="prev" title="2d MPI example">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="MPI-Data-Distribution"></span><div class="header">
<p>
Next: <a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html" accesskey="n" rel="next">Multi-dimensional MPI DFTs of Real Data</a>, Previous: <a href="2d-MPI-example.html" accesskey="p" rel="prev">2d MPI example</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="MPI-Data-Distribution-1"></span><h3 class="section">6.4 MPI Data Distribution</h3>
<span id="index-data-distribution-2"></span>
<p>The most important concept to understand in using FFTW&rsquo;s MPI interface
is the data distribution. With a serial or multithreaded FFT, all of
the inputs and outputs are stored as a single contiguous chunk of
memory. With a distributed-memory FFT, the inputs and outputs are
broken into disjoint blocks, one per process.
</p>
<p>In particular, FFTW uses a <em>1d block distribution</em> of the data,
distributed along the <em>first dimension</em>. For example, if you
want to perform a 100&nbsp;&times;&nbsp;200
complex DFT, distributed over 4
processes, each process will get a 25&nbsp;&times;&nbsp;200
slice of the data.
That is, process 0 will get rows 0 through 24, process 1 will get rows
25 through 49, process 2 will get rows 50 through 74, and process 3
will get rows 75 through 99. If you take the same array but
distribute it over 3 processes, then it is not evenly divisible so the
different processes will have unequal chunks. FFTW&rsquo;s default choice
in this case is to assign 34 rows to processes 0 and 1, and 32 rows to
process 2.
<span id="index-block-distribution"></span>
</p>
<p>FFTW provides several &lsquo;<samp>fftw_mpi_local_size</samp>&rsquo; routines that you can
call to find out what portion of an array is stored on the current
process. In most cases, you should use the default block sizes picked
by FFTW, but it is also possible to specify your own block size. For
example, with a 100&nbsp;&times;&nbsp;200
array on three processes, you can
tell FFTW to use a block size of 40, which would assign 40 rows to
processes 0 and 1, and 20 rows to process 2. FFTW&rsquo;s default is to
divide the data equally among the processes if possible, and as best
it can otherwise. The rows are always assigned in &ldquo;rank order,&rdquo;
i.e. process 0 gets the first block of rows, then process 1, and so
on. (You can change this by using <code>MPI_Comm_split</code> to create a
new communicator with re-ordered processes.) However, you should
always call the &lsquo;<samp>fftw_mpi_local_size</samp>&rsquo; routines, if possible,
rather than trying to predict FFTW&rsquo;s distribution choices.
</p>
<p>In particular, it is critical that you allocate the storage size that
is returned by &lsquo;<samp>fftw_mpi_local_size</samp>&rsquo;, which is <em>not</em>
necessarily the size of the local slice of the array. The reason is
that intermediate steps of FFTW&rsquo;s algorithms involve transposing the
array and redistributing the data, so at these intermediate steps FFTW
may require more local storage space (albeit always proportional to
the total size divided by the number of processes). The
&lsquo;<samp>fftw_mpi_local_size</samp>&rsquo; functions know how much storage is required
for these intermediate steps and tell you the correct amount to
allocate.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Basic-and-advanced-distribution-interfaces.html" accesskey="1">Basic and advanced distribution interfaces</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Load-balancing.html" accesskey="2">Load balancing</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Transposed-distributions.html" accesskey="3">Transposed distributions</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="One_002ddimensional-distributions.html" accesskey="4">One-dimensional distributions</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<hr>
<div class="header">
<p>
Next: <a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html" accesskey="n" rel="next">Multi-dimensional MPI DFTs of Real Data</a>, Previous: <a href="2d-MPI-example.html" accesskey="p" rel="prev">2d MPI example</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

95
fftw-3.3.10/doc/html/MPI-Files-and-Data-Types.html Normal file
View File

@@ -0,0 +1,95 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>MPI Files and Data Types (FFTW 3.3.10)</title>
<meta name="description" content="MPI Files and Data Types (FFTW 3.3.10)">
<meta name="keywords" content="MPI Files and Data Types (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Reference.html" rel="up" title="FFTW MPI Reference">
<link href="MPI-Initialization.html" rel="next" title="MPI Initialization">
<link href="FFTW-MPI-Reference.html" rel="prev" title="FFTW MPI Reference">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="MPI-Files-and-Data-Types"></span><div class="header">
<p>
Next: <a href="MPI-Initialization.html" accesskey="n" rel="next">MPI Initialization</a>, Previous: <a href="FFTW-MPI-Reference.html" accesskey="p" rel="prev">FFTW MPI Reference</a>, Up: <a href="FFTW-MPI-Reference.html" accesskey="u" rel="up">FFTW MPI Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="MPI-Files-and-Data-Types-1"></span><h4 class="subsection">6.12.1 MPI Files and Data Types</h4>
<p>All programs using FFTW&rsquo;s MPI support should include its header file:
</p>
<div class="example">
<pre class="example">#include &lt;fftw3-mpi.h&gt;
</pre></div>
<p>Note that this header file includes the serial-FFTW <code>fftw3.h</code>
header file, and also the <code>mpi.h</code> header file for MPI, so you
need not include those files separately.
</p>
<p>You must also link to <em>both</em> the FFTW MPI library and to the
serial FFTW library. On Unix, this means adding <code>-lfftw3_mpi
-lfftw3 -lm</code> at the end of the link command.
</p>
<span id="index-precision-6"></span>
<p>Different precisions are handled as in the serial interface:
See <a href="Precision.html">Precision</a>. That is, &lsquo;<samp>fftw_</samp>&rsquo; functions become
<code>fftwf_</code> (in single precision) etcetera, and the libraries become
<code>-lfftw3f_mpi -lfftw3f -lm</code> etcetera on Unix. Long-double
precision is supported in MPI, but quad precision (&lsquo;<samp>fftwq_</samp>&rsquo;) is
not due to the lack of MPI support for this type.
</p>
</body>
</html>

103
fftw-3.3.10/doc/html/MPI-Initialization.html Normal file
View File

@@ -0,0 +1,103 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>MPI Initialization (FFTW 3.3.10)</title>
<meta name="description" content="MPI Initialization (FFTW 3.3.10)">
<meta name="keywords" content="MPI Initialization (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Reference.html" rel="up" title="FFTW MPI Reference">
<link href="Using-MPI-Plans.html" rel="next" title="Using MPI Plans">
<link href="MPI-Files-and-Data-Types.html" rel="prev" title="MPI Files and Data Types">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="MPI-Initialization"></span><div class="header">
<p>
Next: <a href="Using-MPI-Plans.html" accesskey="n" rel="next">Using MPI Plans</a>, Previous: <a href="MPI-Files-and-Data-Types.html" accesskey="p" rel="prev">MPI Files and Data Types</a>, Up: <a href="FFTW-MPI-Reference.html" accesskey="u" rel="up">FFTW MPI Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="MPI-Initialization-1"></span><h4 class="subsection">6.12.2 MPI Initialization</h4>
<p>Before calling any other FFTW MPI (&lsquo;<samp>fftw_mpi_</samp>&rsquo;) function, and
before importing any wisdom for MPI problems, you must call:
</p>
<span id="index-fftw_005fmpi_005finit-4"></span>
<div class="example">
<pre class="example">void fftw_mpi_init(void);
</pre></div>
<span id="index-fftw_005finit_005fthreads-3"></span>
<p>If FFTW threads support is used, however, <code>fftw_mpi_init</code> should
be called <em>after</em> <code>fftw_init_threads</code> (see <a href="Combining-MPI-and-Threads.html">Combining MPI and Threads</a>). Calling <code>fftw_mpi_init</code> additional times (before
<code>fftw_mpi_cleanup</code>) has no effect.
</p>
<p>If you want to deallocate all persistent data and reset FFTW to the
pristine state it was in when you started your program, you can call:
</p>
<span id="index-fftw_005fmpi_005fcleanup-1"></span>
<div class="example">
<pre class="example">void fftw_mpi_cleanup(void);
</pre></div>
<span id="index-fftw_005fcleanup-1"></span>
<p>(This calls <code>fftw_cleanup</code>, so you need not call the serial
cleanup routine too, although it is safe to do so.) After calling
<code>fftw_mpi_cleanup</code>, all existing plans become undefined, and you
should not attempt to execute or destroy them. You must call
<code>fftw_mpi_init</code> again after <code>fftw_mpi_cleanup</code> if you want
to resume using the MPI FFTW routines.
</p>
</body>
</html>

313
fftw-3.3.10/doc/html/MPI-Plan-Creation.html Normal file
View File

@@ -0,0 +1,313 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>MPI Plan Creation (FFTW 3.3.10)</title>
<meta name="description" content="MPI Plan Creation (FFTW 3.3.10)">
<meta name="keywords" content="MPI Plan Creation (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Reference.html" rel="up" title="FFTW MPI Reference">
<link href="MPI-Wisdom-Communication.html" rel="next" title="MPI Wisdom Communication">
<link href="MPI-Data-Distribution-Functions.html" rel="prev" title="MPI Data Distribution Functions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="MPI-Plan-Creation"></span><div class="header">
<p>
Next: <a href="MPI-Wisdom-Communication.html" accesskey="n" rel="next">MPI Wisdom Communication</a>, Previous: <a href="MPI-Data-Distribution-Functions.html" accesskey="p" rel="prev">MPI Data Distribution Functions</a>, Up: <a href="FFTW-MPI-Reference.html" accesskey="u" rel="up">FFTW MPI Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="MPI-Plan-Creation-1"></span><h4 class="subsection">6.12.5 MPI Plan Creation</h4>
<span id="Complex_002ddata-MPI-DFTs"></span><h4 class="subsubheading">Complex-data MPI DFTs</h4>
<p>Plans for complex-data DFTs (see <a href="2d-MPI-example.html">2d MPI example</a>) are created by:
</p>
<span id="index-fftw_005fmpi_005fplan_005fdft_005f1d"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005f2d-1"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005f3d"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft"></span>
<span id="index-fftw_005fmpi_005fplan_005fmany_005fdft"></span>
<div class="example">
<pre class="example">fftw_plan fftw_mpi_plan_dft_1d(ptrdiff_t n0, fftw_complex *in, fftw_complex *out,
MPI_Comm comm, int sign, unsigned flags);
fftw_plan fftw_mpi_plan_dft_2d(ptrdiff_t n0, ptrdiff_t n1,
fftw_complex *in, fftw_complex *out,
MPI_Comm comm, int sign, unsigned flags);
fftw_plan fftw_mpi_plan_dft_3d(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t n2,
fftw_complex *in, fftw_complex *out,
MPI_Comm comm, int sign, unsigned flags);
fftw_plan fftw_mpi_plan_dft(int rnk, const ptrdiff_t *n,
fftw_complex *in, fftw_complex *out,
MPI_Comm comm, int sign, unsigned flags);
fftw_plan fftw_mpi_plan_many_dft(int rnk, const ptrdiff_t *n,
ptrdiff_t howmany, ptrdiff_t block, ptrdiff_t tblock,
fftw_complex *in, fftw_complex *out,
MPI_Comm comm, int sign, unsigned flags);
</pre></div>
<span id="index-MPI-communicator-2"></span>
<span id="index-collective-function-4"></span>
<p>These are similar to their serial counterparts (see <a href="Complex-DFTs.html">Complex DFTs</a>)
in specifying the dimensions, sign, and flags of the transform. The
<code>comm</code> argument gives an MPI communicator that specifies the set
of processes to participate in the transform; plan creation is a
collective function that must be called for all processes in the
communicator. The <code>in</code> and <code>out</code> pointers refer only to a
portion of the overall transform data (see <a href="MPI-Data-Distribution.html">MPI Data Distribution</a>)
as specified by the &lsquo;<samp>local_size</samp>&rsquo; functions in the previous
section. Unless <code>flags</code> contains <code>FFTW_ESTIMATE</code>, these
arrays are overwritten during plan creation as for the serial
interface. For multi-dimensional transforms, any dimensions <code>&gt;
1</code> are supported; for one-dimensional transforms, only composite
(non-prime) <code>n0</code> are currently supported (unlike the serial
FFTW). Requesting an unsupported transform size will yield a
<code>NULL</code> plan. (As in the serial interface, highly composite sizes
generally yield the best performance.)
</p>
<span id="index-advanced-interface-6"></span>
<span id="index-FFTW_005fMPI_005fDEFAULT_005fBLOCK-2"></span>
<span id="index-stride-3"></span>
<p>The advanced-interface <code>fftw_mpi_plan_many_dft</code> additionally
allows you to specify the block sizes for the first dimension
(<code>block</code>) of the n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
input data and the first dimension
(<code>tblock</code>) of the n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&hellip;&times;&nbsp;n<sub>d-1</sub>
transposed data (at intermediate
steps of the transform, and for the output if
<code>FFTW_TRANSPOSED_OUT</code> is specified in <code>flags</code>). These must
be the same block sizes as were passed to the corresponding
&lsquo;<samp>local_size</samp>&rsquo; function; you can pass <code>FFTW_MPI_DEFAULT_BLOCK</code>
to use FFTW&rsquo;s default block size as in the basic interface. Also, the
<code>howmany</code> parameter specifies that the transform is of contiguous
<code>howmany</code>-tuples rather than individual complex numbers; this
corresponds to the same parameter in the serial advanced interface
(see <a href="Advanced-Complex-DFTs.html">Advanced Complex DFTs</a>) with <code>stride = howmany</code> and
<code>dist = 1</code>.
</p>
<span id="MPI-flags"></span><h4 class="subsubheading">MPI flags</h4>
<p>The <code>flags</code> can be any of those for the serial FFTW
(see <a href="Planner-Flags.html">Planner Flags</a>), and in addition may include one or more of
the following MPI-specific flags, which improve performance at the
cost of changing the output or input data formats.
</p>
<ul>
<li> <span id="index-FFTW_005fMPI_005fSCRAMBLED_005fOUT-2"></span>
<span id="index-FFTW_005fMPI_005fSCRAMBLED_005fIN-2"></span>
<code>FFTW_MPI_SCRAMBLED_OUT</code>, <code>FFTW_MPI_SCRAMBLED_IN</code>: valid for
1d transforms only, these flags indicate that the output/input of the
transform are in an undocumented &ldquo;scrambled&rdquo; order. A forward
<code>FFTW_MPI_SCRAMBLED_OUT</code> transform can be inverted by a backward
<code>FFTW_MPI_SCRAMBLED_IN</code> (times the usual 1/<i>N</i> normalization).
See <a href="One_002ddimensional-distributions.html">One-dimensional distributions</a>.
</li><li> <span id="index-FFTW_005fMPI_005fTRANSPOSED_005fOUT-2"></span>
<span id="index-FFTW_005fMPI_005fTRANSPOSED_005fIN-2"></span>
<code>FFTW_MPI_TRANSPOSED_OUT</code>, <code>FFTW_MPI_TRANSPOSED_IN</code>: valid
for multidimensional (<code>rnk &gt; 1</code>) transforms only, these flags
specify that the output or input of an n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
transform is
transposed to n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&hellip;&times;&nbsp;n<sub>d-1</sub>
. See <a href="Transposed-distributions.html">Transposed distributions</a>.
</li></ul>
<span id="Real_002ddata-MPI-DFTs"></span><h4 class="subsubheading">Real-data MPI DFTs</h4>
<span id="index-r2c-4"></span>
<p>Plans for real-input/output (r2c/c2r) DFTs (see <a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a>) are created by:
</p>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fr2c_005f2d"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fr2c_005f2d-1"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fr2c_005f3d"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fr2c"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fc2r_005f2d"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fc2r_005f2d-1"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fc2r_005f3d"></span>
<span id="index-fftw_005fmpi_005fplan_005fdft_005fc2r"></span>
<div class="example">
<pre class="example">fftw_plan fftw_mpi_plan_dft_r2c_2d(ptrdiff_t n0, ptrdiff_t n1,
double *in, fftw_complex *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_dft_r2c_2d(ptrdiff_t n0, ptrdiff_t n1,
double *in, fftw_complex *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_dft_r2c_3d(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t n2,
double *in, fftw_complex *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_dft_r2c(int rnk, const ptrdiff_t *n,
double *in, fftw_complex *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_dft_c2r_2d(ptrdiff_t n0, ptrdiff_t n1,
fftw_complex *in, double *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_dft_c2r_2d(ptrdiff_t n0, ptrdiff_t n1,
fftw_complex *in, double *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_dft_c2r_3d(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t n2,
fftw_complex *in, double *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_dft_c2r(int rnk, const ptrdiff_t *n,
fftw_complex *in, double *out,
MPI_Comm comm, unsigned flags);
</pre></div>
<p>Similar to the serial interface (see <a href="Real_002ddata-DFTs.html">Real-data DFTs</a>), these
transform logically n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
real data to/from n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;(n<sub>d-1</sub>/2 + 1)
complex
data, representing the non-redundant half of the conjugate-symmetry
output of a real-input DFT (see <a href="Multi_002ddimensional-Transforms.html">Multi-dimensional Transforms</a>).
However, the real array must be stored within a padded n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;[2&nbsp;(n<sub>d-1</sub>/2 + 1)]
array (much like the in-place serial r2c transforms, but here for
out-of-place transforms as well). Currently, only multi-dimensional
(<code>rnk &gt; 1</code>) r2c/c2r transforms are supported (requesting a plan
for <code>rnk = 1</code> will yield <code>NULL</code>). As explained above
(see <a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html">Multi-dimensional MPI DFTs of Real Data</a>), the data
distribution of both the real and complex arrays is given by the
&lsquo;<samp>local_size</samp>&rsquo; function called for the dimensions of the
<em>complex</em> array. Similar to the other planning functions, the
input and output arrays are overwritten when the plan is created
except in <code>FFTW_ESTIMATE</code> mode.
</p>
<p>As for the complex DFTs above, there is an advance interface that
allows you to manually specify block sizes and to transform contiguous
<code>howmany</code>-tuples of real/complex numbers:
</p>
<span id="index-fftw_005fmpi_005fplan_005fmany_005fdft_005fr2c"></span>
<span id="index-fftw_005fmpi_005fplan_005fmany_005fdft_005fc2r"></span>
<div class="example">
<pre class="example">fftw_plan fftw_mpi_plan_many_dft_r2c
(int rnk, const ptrdiff_t *n, ptrdiff_t howmany,
ptrdiff_t iblock, ptrdiff_t oblock,
double *in, fftw_complex *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_many_dft_c2r
(int rnk, const ptrdiff_t *n, ptrdiff_t howmany,
ptrdiff_t iblock, ptrdiff_t oblock,
fftw_complex *in, double *out,
MPI_Comm comm, unsigned flags);
</pre></div>
<span id="MPI-r2r-transforms"></span><h4 class="subsubheading">MPI r2r transforms</h4>
<span id="index-r2r-4"></span>
<p>There are corresponding plan-creation routines for r2r
transforms (see <a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a>), currently supporting
multidimensional (<code>rnk &gt; 1</code>) transforms only (<code>rnk = 1</code> will
yield a <code>NULL</code> plan):
</p>
<div class="example">
<pre class="example">fftw_plan fftw_mpi_plan_r2r_2d(ptrdiff_t n0, ptrdiff_t n1,
double *in, double *out,
MPI_Comm comm,
fftw_r2r_kind kind0, fftw_r2r_kind kind1,
unsigned flags);
fftw_plan fftw_mpi_plan_r2r_3d(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t n2,
double *in, double *out,
MPI_Comm comm,
fftw_r2r_kind kind0, fftw_r2r_kind kind1, fftw_r2r_kind kind2,
unsigned flags);
fftw_plan fftw_mpi_plan_r2r(int rnk, const ptrdiff_t *n,
double *in, double *out,
MPI_Comm comm, const fftw_r2r_kind *kind,
unsigned flags);
fftw_plan fftw_mpi_plan_many_r2r(int rnk, const ptrdiff_t *n,
ptrdiff_t iblock, ptrdiff_t oblock,
double *in, double *out,
MPI_Comm comm, const fftw_r2r_kind *kind,
unsigned flags);
</pre></div>
<p>The parameters are much the same as for the complex DFTs above, except
that the arrays are of real numbers (and hence the outputs of the
&lsquo;<samp>local_size</samp>&rsquo; data-distribution functions should be interpreted as
counts of real rather than complex numbers). Also, the <code>kind</code>
parameters specify the r2r kinds along each dimension as for the
serial interface (see <a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a>). See <a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html">Other Multi-dimensional Real-data MPI Transforms</a>.
</p>
<span id="MPI-transposition"></span><h4 class="subsubheading">MPI transposition</h4>
<span id="index-transpose-5"></span>
<p>FFTW also provides routines to plan a transpose of a distributed
<code>n0</code> by <code>n1</code> array of real numbers, or an array of
<code>howmany</code>-tuples of real numbers with specified block sizes
(see <a href="FFTW-MPI-Transposes.html">FFTW MPI Transposes</a>):
</p>
<span id="index-fftw_005fmpi_005fplan_005ftranspose-1"></span>
<span id="index-fftw_005fmpi_005fplan_005fmany_005ftranspose-1"></span>
<div class="example">
<pre class="example">fftw_plan fftw_mpi_plan_transpose(ptrdiff_t n0, ptrdiff_t n1,
double *in, double *out,
MPI_Comm comm, unsigned flags);
fftw_plan fftw_mpi_plan_many_transpose
(ptrdiff_t n0, ptrdiff_t n1, ptrdiff_t howmany,
ptrdiff_t block0, ptrdiff_t block1,
double *in, double *out, MPI_Comm comm, unsigned flags);
</pre></div>
<span id="index-new_002darray-execution-2"></span>
<span id="index-fftw_005fmpi_005fexecute_005fr2r-1"></span>
<p>These plans are used with the <code>fftw_mpi_execute_r2r</code> new-array
execute function (see <a href="Using-MPI-Plans.html">Using MPI Plans</a>), since they count as (rank
zero) r2r plans from FFTW&rsquo;s perspective.
</p>
<hr>
<div class="header">
<p>
Next: <a href="MPI-Wisdom-Communication.html" accesskey="n" rel="next">MPI Wisdom Communication</a>, Previous: <a href="MPI-Data-Distribution-Functions.html" accesskey="p" rel="prev">MPI Data Distribution Functions</a>, Up: <a href="FFTW-MPI-Reference.html" accesskey="u" rel="up">FFTW MPI Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

96
fftw-3.3.10/doc/html/MPI-Wisdom-Communication.html Normal file
View File

@@ -0,0 +1,96 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>MPI Wisdom Communication (FFTW 3.3.10)</title>
<meta name="description" content="MPI Wisdom Communication (FFTW 3.3.10)">
<meta name="keywords" content="MPI Wisdom Communication (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-MPI-Reference.html" rel="up" title="FFTW MPI Reference">
<link href="FFTW-MPI-Fortran-Interface.html" rel="next" title="FFTW MPI Fortran Interface">
<link href="MPI-Plan-Creation.html" rel="prev" title="MPI Plan Creation">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="MPI-Wisdom-Communication"></span><div class="header">
<p>
Previous: <a href="MPI-Plan-Creation.html" accesskey="p" rel="prev">MPI Plan Creation</a>, Up: <a href="FFTW-MPI-Reference.html" accesskey="u" rel="up">FFTW MPI Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="MPI-Wisdom-Communication-1"></span><h4 class="subsection">6.12.6 MPI Wisdom Communication</h4>
<p>To facilitate synchronizing wisdom among the different MPI processes,
we provide two functions:
</p>
<span id="index-fftw_005fmpi_005fgather_005fwisdom-1"></span>
<span id="index-fftw_005fmpi_005fbroadcast_005fwisdom-1"></span>
<div class="example">
<pre class="example">void fftw_mpi_gather_wisdom(MPI_Comm comm);
void fftw_mpi_broadcast_wisdom(MPI_Comm comm);
</pre></div>
<p>The <code>fftw_mpi_gather_wisdom</code> function gathers all wisdom in the
given communicator <code>comm</code> to the process of rank 0 in the
communicator: that process obtains the union of all wisdom on all the
processes. As a side effect, some other processes will gain
additional wisdom from other processes, but only process 0 will gain
the complete union.
</p>
<p>The <code>fftw_mpi_broadcast_wisdom</code> does the reverse: it exports
wisdom from process 0 in <code>comm</code> to all other processes in the
communicator, replacing any wisdom they currently have.
</p>
<p>See <a href="FFTW-MPI-Wisdom.html">FFTW MPI Wisdom</a>.
</p>
</body>
</html>

120
fftw-3.3.10/doc/html/Memory-Allocation.html Normal file
View File

@@ -0,0 +1,120 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Memory Allocation (FFTW 3.3.10)</title>
<meta name="description" content="Memory Allocation (FFTW 3.3.10)">
<meta name="keywords" content="Memory Allocation (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Data-Types-and-Files.html" rel="up" title="Data Types and Files">
<link href="Using-Plans.html" rel="next" title="Using Plans">
<link href="Precision.html" rel="prev" title="Precision">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Memory-Allocation"></span><div class="header">
<p>
Previous: <a href="Precision.html" accesskey="p" rel="prev">Precision</a>, Up: <a href="Data-Types-and-Files.html" accesskey="u" rel="up">Data Types and Files</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Memory-Allocation-1"></span><h4 class="subsection">4.1.3 Memory Allocation</h4>
<div class="example">
<pre class="example">void *fftw_malloc(size_t n);
void fftw_free(void *p);
</pre></div>
<span id="index-fftw_005fmalloc-3"></span>
<span id="index-fftw_005ffree-2"></span>
<p>These are functions that behave identically to <code>malloc</code> and
<code>free</code>, except that they guarantee that the returned pointer obeys
any special alignment restrictions imposed by any algorithm in FFTW
(e.g. for SIMD acceleration). See <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>.
<span id="index-alignment"></span>
</p>
<p>Data allocated by <code>fftw_malloc</code> <em>must</em> be deallocated by
<code>fftw_free</code> and not by the ordinary <code>free</code>.
</p>
<p>These routines simply call through to your operating system&rsquo;s
<code>malloc</code> or, if necessary, its aligned equivalent
(e.g. <code>memalign</code>), so you normally need not worry about any
significant time or space overhead. You are <em>not required</em> to use
them to allocate your data, but we strongly recommend it.
</p>
<p>Note: in C++, just as with ordinary <code>malloc</code>, you must typecast
the output of <code>fftw_malloc</code> to whatever pointer type you are
allocating.
<span id="index-C_002b_002b-4"></span>
</p>
<p>We also provide the following two convenience functions to allocate
real and complex arrays with <code>n</code> elements, which are equivalent
to <code>(double *) fftw_malloc(sizeof(double) * n)</code> and
<code>(fftw_complex *) fftw_malloc(sizeof(fftw_complex) * n)</code>,
respectively:
</p>
<div class="example">
<pre class="example">double *fftw_alloc_real(size_t n);
fftw_complex *fftw_alloc_complex(size_t n);
</pre></div>
<span id="index-fftw_005falloc_005freal-1"></span>
<span id="index-fftw_005falloc_005fcomplex-2"></span>
<p>The equivalent functions in other precisions allocate arrays of <code>n</code>
elements in that precision. e.g. <code>fftwf_alloc_real(n)</code> is
equivalent to <code>(float *) fftwf_malloc(sizeof(float) * n)</code>.
<span id="index-precision-4"></span>
</p>
</body>
</html>

157
fftw-3.3.10/doc/html/More-DFTs-of-Real-Data.html Normal file
View File

@@ -0,0 +1,157 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>More DFTs of Real Data (FFTW 3.3.10)</title>
<meta name="description" content="More DFTs of Real Data (FFTW 3.3.10)">
<meta name="keywords" content="More DFTs of Real Data (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Tutorial.html" rel="up" title="Tutorial">
<link href="The-Halfcomplex_002dformat-DFT.html" rel="next" title="The Halfcomplex-format DFT">
<link href="Multi_002dDimensional-DFTs-of-Real-Data.html" rel="prev" title="Multi-Dimensional DFTs of Real Data">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="More-DFTs-of-Real-Data"></span><div class="header">
<p>
Previous: <a href="Multi_002dDimensional-DFTs-of-Real-Data.html" accesskey="p" rel="prev">Multi-Dimensional DFTs of Real Data</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="More-DFTs-of-Real-Data-1"></span><h3 class="section">2.5 More DFTs of Real Data</h3>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="The-Halfcomplex_002dformat-DFT.html" accesskey="1">The Halfcomplex-format DFT</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html" accesskey="2">Real even/odd DFTs (cosine/sine transforms)</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="The-Discrete-Hartley-Transform.html" accesskey="3">The Discrete Hartley Transform</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<p>FFTW supports several other transform types via a unified <em>r2r</em>
(real-to-real) interface,
<span id="index-r2r"></span>
so called because it takes a real (<code>double</code>) array and outputs a
real array of the same size. These r2r transforms currently fall into
three categories: DFTs of real input and complex-Hermitian output in
halfcomplex format, DFTs of real input with even/odd symmetry
(a.k.a. discrete cosine/sine transforms, DCTs/DSTs), and discrete
Hartley transforms (DHTs), all described in more detail by the
following sections.
</p>
<p>The r2r transforms follow the by now familiar interface of creating an
<code>fftw_plan</code>, executing it with <code>fftw_execute(plan)</code>, and
destroying it with <code>fftw_destroy_plan(plan)</code>. Furthermore, all
r2r transforms share the same planner interface:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_plan_r2r_1d(int n, double *in, double *out,
fftw_r2r_kind kind, unsigned flags);
fftw_plan fftw_plan_r2r_2d(int n0, int n1, double *in, double *out,
fftw_r2r_kind kind0, fftw_r2r_kind kind1,
unsigned flags);
fftw_plan fftw_plan_r2r_3d(int n0, int n1, int n2,
double *in, double *out,
fftw_r2r_kind kind0,
fftw_r2r_kind kind1,
fftw_r2r_kind kind2,
unsigned flags);
fftw_plan fftw_plan_r2r(int rank, const int *n, double *in, double *out,
const fftw_r2r_kind *kind, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fr2r_005f1d"></span>
<span id="index-fftw_005fplan_005fr2r_005f2d"></span>
<span id="index-fftw_005fplan_005fr2r_005f3d"></span>
<span id="index-fftw_005fplan_005fr2r"></span>
<p>Just as for the complex DFT, these plan 1d/2d/3d/multi-dimensional
transforms for contiguous arrays in row-major order, transforming (real)
input to output of the same size, where <code>n</code> specifies the
<em>physical</em> dimensions of the arrays. All positive <code>n</code> are
supported (with the exception of <code>n=1</code> for the <code>FFTW_REDFT00</code>
kind, noted in the real-even subsection below); products of small
factors are most efficient (factorizing <code>n-1</code> and <code>n+1</code> for
<code>FFTW_REDFT00</code> and <code>FFTW_RODFT00</code> kinds, described below), but
an <i>O</i>(<i>n</i>&nbsp;log&nbsp;<i>n</i>)
algorithm is used even for prime sizes.
</p>
<p>Each dimension has a <em>kind</em> parameter, of type
<code>fftw_r2r_kind</code>, specifying the kind of r2r transform to be used
for that dimension.
<span id="index-kind-_0028r2r_0029"></span>
<span id="index-fftw_005fr2r_005fkind"></span>
(In the case of <code>fftw_plan_r2r</code>, this is an array <code>kind[rank]</code>
where <code>kind[i]</code> is the transform kind for the dimension
<code>n[i]</code>.) The kind can be one of a set of predefined constants,
defined in the following subsections.
</p>
<p>In other words, FFTW computes the separable product of the specified
r2r transforms over each dimension, which can be used e.g. for partial
differential equations with mixed boundary conditions. (For some r2r
kinds, notably the halfcomplex DFT and the DHT, such a separable
product is somewhat problematic in more than one dimension, however,
as is described below.)
</p>
<p>In the current version of FFTW, all r2r transforms except for the
halfcomplex type are computed via pre- or post-processing of
halfcomplex transforms, and they are therefore not as fast as they
could be. Since most other general DCT/DST codes employ a similar
algorithm, however, FFTW&rsquo;s implementation should provide at least
competitive performance.
</p>
<hr>
<div class="header">
<p>
Previous: <a href="Multi_002dDimensional-DFTs-of-Real-Data.html" accesskey="p" rel="prev">Multi-Dimensional DFTs of Real Data</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

167
fftw-3.3.10/doc/html/Multi_002dDimensional-DFTs-of-Real-Data.html Normal file
View File

@@ -0,0 +1,167 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Multi-Dimensional DFTs of Real Data (FFTW 3.3.10)</title>
<meta name="description" content="Multi-Dimensional DFTs of Real Data (FFTW 3.3.10)">
<meta name="keywords" content="Multi-Dimensional DFTs of Real Data (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Tutorial.html" rel="up" title="Tutorial">
<link href="More-DFTs-of-Real-Data.html" rel="next" title="More DFTs of Real Data">
<link href="One_002dDimensional-DFTs-of-Real-Data.html" rel="prev" title="One-Dimensional DFTs of Real Data">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Multi_002dDimensional-DFTs-of-Real-Data"></span><div class="header">
<p>
Next: <a href="More-DFTs-of-Real-Data.html" accesskey="n" rel="next">More DFTs of Real Data</a>, Previous: <a href="One_002dDimensional-DFTs-of-Real-Data.html" accesskey="p" rel="prev">One-Dimensional DFTs of Real Data</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Multi_002dDimensional-DFTs-of-Real-Data-1"></span><h3 class="section">2.4 Multi-Dimensional DFTs of Real Data</h3>
<p>Multi-dimensional DFTs of real data use the following planner routines:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_plan_dft_r2c_2d(int n0, int n1,
double *in, fftw_complex *out,
unsigned flags);
fftw_plan fftw_plan_dft_r2c_3d(int n0, int n1, int n2,
double *in, fftw_complex *out,
unsigned flags);
fftw_plan fftw_plan_dft_r2c(int rank, const int *n,
double *in, fftw_complex *out,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft_005fr2c_005f2d"></span>
<span id="index-fftw_005fplan_005fdft_005fr2c_005f3d"></span>
<span id="index-fftw_005fplan_005fdft_005fr2c"></span>
<p>as well as the corresponding <code>c2r</code> routines with the input/output
types swapped. These routines work similarly to their complex
analogues, except for the fact that here the complex output array is cut
roughly in half and the real array requires padding for in-place
transforms (as in 1d, above).
</p>
<p>As before, <code>n</code> is the logical size of the array, and the
consequences of this on the the format of the complex arrays deserve
careful attention.
<span id="index-r2c_002fc2r-multi_002ddimensional-array-format"></span>
Suppose that the real data has dimensions n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
(in row-major order).
Then, after an r2c transform, the output is an n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;(n<sub>d-1</sub>/2 + 1)
array of
<code>fftw_complex</code> values in row-major order, corresponding to slightly
over half of the output of the corresponding complex DFT. (The division
is rounded down.) The ordering of the data is otherwise exactly the
same as in the complex-DFT case.
</p>
<p>For out-of-place transforms, this is the end of the story: the real
data is stored as a row-major array of size n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
and the complex
data is stored as a row-major array of size n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;(n<sub>d-1</sub>/2 + 1)
.
</p>
<p>For in-place transforms, however, extra padding of the real-data array
is necessary because the complex array is larger than the real array,
and the two arrays share the same memory locations. Thus, for
in-place transforms, the final dimension of the real-data array must
be padded with extra values to accommodate the size of the complex
data&mdash;two values if the last dimension is even and one if it is odd.
<span id="index-padding-1"></span>
That is, the last dimension of the real data must physically contain
2 * (n<sub>d-1</sub>/2+1)
<code>double</code> values (exactly enough to hold the complex data).
This physical array size does not, however, change the <em>logical</em>
array size&mdash;only
n<sub>d-1</sub>
values are actually stored in the last dimension, and
n<sub>d-1</sub>
is the last dimension passed to the plan-creation routine.
</p>
<p>For example, consider the transform of a two-dimensional real array of
size <code>n0</code> by <code>n1</code>. The output of the r2c transform is a
two-dimensional complex array of size <code>n0</code> by <code>n1/2+1</code>, where
the <code>y</code> dimension has been cut nearly in half because of
redundancies in the output. Because <code>fftw_complex</code> is twice the
size of <code>double</code>, the output array is slightly bigger than the
input array. Thus, if we want to compute the transform in place, we
must <em>pad</em> the input array so that it is of size <code>n0</code> by
<code>2*(n1/2+1)</code>. If <code>n1</code> is even, then there are two padding
elements at the end of each row (which need not be initialized, as they
are only used for output).
</p>
<p>The following illustration depicts the input and output arrays just
described, for both the out-of-place and in-place transforms (with the
arrows indicating consecutive memory locations):
<img src="rfftwnd-for-html.png" alt="rfftwnd-for-html">
</p>
<p>These transforms are unnormalized, so an r2c followed by a c2r
transform (or vice versa) will result in the original data scaled by
the number of real data elements&mdash;that is, the product of the
(logical) dimensions of the real data.
<span id="index-normalization-1"></span>
</p>
<p>(Because the last dimension is treated specially, if it is equal to
<code>1</code> the transform is <em>not</em> equivalent to a lower-dimensional
r2c/c2r transform. In that case, the last complex dimension also has
size <code>1</code> (<code>=1/2+1</code>), and no advantage is gained over the
complex transforms.)
</p>
<hr>
<div class="header">
<p>
Next: <a href="More-DFTs-of-Real-Data.html" accesskey="n" rel="next">More DFTs of Real Data</a>, Previous: <a href="One_002dDimensional-DFTs-of-Real-Data.html" accesskey="p" rel="prev">One-Dimensional DFTs of Real Data</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

91
fftw-3.3.10/doc/html/Multi_002ddimensional-Array-Format.html Normal file
View File

@@ -0,0 +1,91 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Multi-dimensional Array Format (FFTW 3.3.10)</title>
<meta name="description" content="Multi-dimensional Array Format (FFTW 3.3.10)">
<meta name="keywords" content="Multi-dimensional Array Format (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Other-Important-Topics.html" rel="up" title="Other Important Topics">
<link href="Row_002dmajor-Format.html" rel="next" title="Row-major Format">
<link href="SIMD-alignment-and-fftw_005fmalloc.html" rel="prev" title="SIMD alignment and fftw_malloc">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Multi_002ddimensional-Array-Format"></span><div class="header">
<p>
Next: <a href="Words-of-Wisdom_002dSaving-Plans.html" accesskey="n" rel="next">Words of Wisdom-Saving Plans</a>, Previous: <a href="SIMD-alignment-and-fftw_005fmalloc.html" accesskey="p" rel="prev">SIMD alignment and fftw_malloc</a>, Up: <a href="Other-Important-Topics.html" accesskey="u" rel="up">Other Important Topics</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Multi_002ddimensional-Array-Format-1"></span><h3 class="section">3.2 Multi-dimensional Array Format</h3>
<p>This section describes the format in which multi-dimensional arrays
are stored in FFTW. We felt that a detailed discussion of this topic
was necessary. Since several different formats are common, this topic
is often a source of confusion.
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Row_002dmajor-Format.html" accesskey="1">Row-major Format</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Column_002dmajor-Format.html" accesskey="2">Column-major Format</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Fixed_002dsize-Arrays-in-C.html" accesskey="3">Fixed-size Arrays in C</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Dynamic-Arrays-in-C.html" accesskey="4">Dynamic Arrays in C</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Dynamic-Arrays-in-C_002dThe-Wrong-Way.html" accesskey="5">Dynamic Arrays in C-The Wrong Way</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

195
fftw-3.3.10/doc/html/Multi_002ddimensional-MPI-DFTs-of-Real-Data.html Normal file
View File

@@ -0,0 +1,195 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Multi-dimensional MPI DFTs of Real Data (FFTW 3.3.10)</title>
<meta name="description" content="Multi-dimensional MPI DFTs of Real Data (FFTW 3.3.10)">
<meta name="keywords" content="Multi-dimensional MPI DFTs of Real Data (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html" rel="next" title="Other Multi-dimensional Real-data MPI Transforms">
<link href="One_002ddimensional-distributions.html" rel="prev" title="One-dimensional distributions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Multi_002ddimensional-MPI-DFTs-of-Real-Data"></span><div class="header">
<p>
Next: <a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html" accesskey="n" rel="next">Other Multi-dimensional Real-data MPI Transforms</a>, Previous: <a href="MPI-Data-Distribution.html" accesskey="p" rel="prev">MPI Data Distribution</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Multi_002ddimensional-MPI-DFTs-of-Real-Data-1"></span><h3 class="section">6.5 Multi-dimensional MPI DFTs of Real Data</h3>
<p>FFTW&rsquo;s MPI interface also supports multi-dimensional DFTs of real
data, similar to the serial r2c and c2r interfaces. (Parallel
one-dimensional real-data DFTs are not currently supported; you must
use a complex transform and set the imaginary parts of the inputs to
zero.)
</p>
<p>The key points to understand for r2c and c2r MPI transforms (compared
to the MPI complex DFTs or the serial r2c/c2r transforms), are:
</p>
<ul>
<li> Just as for serial transforms, r2c/c2r DFTs transform n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
real
data to/from n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;(n<sub>d-1</sub>/2 + 1)
complex data: the last dimension of the
complex data is cut in half (rounded down), plus one. As for the
serial transforms, the sizes you pass to the &lsquo;<samp>plan_dft_r2c</samp>&rsquo; and
&lsquo;<samp>plan_dft_c2r</samp>&rsquo; are the n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
dimensions of the real data.
</li><li> <span id="index-padding-4"></span>
Although the real data is <em>conceptually</em> n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
, it is
<em>physically</em> stored as an n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;[2&nbsp;(n<sub>d-1</sub>/2 + 1)]
array, where the last
dimension has been <em>padded</em> to make it the same size as the
complex output. This is much like the in-place serial r2c/c2r
interface (see <a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a>), except that
in MPI the padding is required even for out-of-place data. The extra
padding numbers are ignored by FFTW (they are <em>not</em> like
zero-padding the transform to a larger size); they are only used to
determine the data layout.
</li><li> <span id="index-data-distribution-3"></span>
The data distribution in MPI for <em>both</em> the real and complex data
is determined by the shape of the <em>complex</em> data. That is, you
call the appropriate &lsquo;<samp>local size</samp>&rsquo; function for the n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;(n<sub>d-1</sub>/2 + 1)
complex data, and then use the <em>same</em> distribution for the real
data except that the last complex dimension is replaced by a (padded)
real dimension of twice the length.
</li></ul>
<p>For example suppose we are performing an out-of-place r2c transform of
L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
real data [padded to L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;2(N/2+1)
],
resulting in L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N/2+1
complex data. Similar to the
example in <a href="2d-MPI-example.html">2d MPI example</a>, we might do something like:
</p>
<div class="example">
<pre class="example">#include &lt;fftw3-mpi.h&gt;
int main(int argc, char **argv)
{
const ptrdiff_t L = ..., M = ..., N = ...;
fftw_plan plan;
double *rin;
fftw_complex *cout;
ptrdiff_t alloc_local, local_n0, local_0_start, i, j, k;
MPI_Init(&amp;argc, &amp;argv);
fftw_mpi_init();
/* <span class="roman">get local data size and allocate</span> */
alloc_local = fftw_mpi_local_size_3d(L, M, N/2+1, MPI_COMM_WORLD,
&amp;local_n0, &amp;local_0_start);
rin = fftw_alloc_real(2 * alloc_local);
cout = fftw_alloc_complex(alloc_local);
/* <span class="roman">create plan for out-of-place r2c DFT</span> */
plan = fftw_mpi_plan_dft_r2c_3d(L, M, N, rin, cout, MPI_COMM_WORLD,
FFTW_MEASURE);
/* <span class="roman">initialize rin to some function</span> my_func(x,y,z) */
for (i = 0; i &lt; local_n0; ++i)
for (j = 0; j &lt; M; ++j)
for (k = 0; k &lt; N; ++k)
rin[(i*M + j) * (2*(N/2+1)) + k] = my_func(local_0_start+i, j, k);
/* <span class="roman">compute transforms as many times as desired</span> */
fftw_execute(plan);
fftw_destroy_plan(plan);
MPI_Finalize();
}
</pre></div>
<span id="index-fftw_005falloc_005freal-2"></span>
<span id="index-row_002dmajor-5"></span>
<p>Note that we allocated <code>rin</code> using <code>fftw_alloc_real</code> with an
argument of <code>2 * alloc_local</code>: since <code>alloc_local</code> is the
number of <em>complex</em> values to allocate, the number of <em>real</em>
values is twice as many. The <code>rin</code> array is then
local_n0&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;2(N/2+1)
in row-major order, so its
<code>(i,j,k)</code> element is at the index <code>(i*M + j) * (2*(N/2+1)) +
k</code> (see <a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>).
</p>
<span id="index-transpose-1"></span>
<span id="index-FFTW_005fTRANSPOSED_005fOUT"></span>
<span id="index-FFTW_005fTRANSPOSED_005fIN"></span>
<p>As for the complex transforms, improved performance can be obtained by
specifying that the output is the transpose of the input or vice versa
(see <a href="Transposed-distributions.html">Transposed distributions</a>). In our L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
r2c
example, including <code>FFTW_TRANSPOSED_OUT</code> in the flags means that
the input would be a padded L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;2(N/2+1)
real array
distributed over the <code>L</code> dimension, while the output would be a
M&nbsp;&times;&nbsp;L&nbsp;&times;&nbsp;N/2+1
complex array distributed over the <code>M</code>
dimension. To perform the inverse c2r transform with the same data
distributions, you would use the <code>FFTW_TRANSPOSED_IN</code> flag.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html" accesskey="n" rel="next">Other Multi-dimensional Real-data MPI Transforms</a>, Previous: <a href="MPI-Data-Distribution.html" accesskey="p" rel="prev">MPI Data Distribution</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

125
fftw-3.3.10/doc/html/Multi_002ddimensional-Transforms.html Normal file
View File

@@ -0,0 +1,125 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Multi-dimensional Transforms (FFTW 3.3.10)</title>
<meta name="description" content="Multi-dimensional Transforms (FFTW 3.3.10)">
<meta name="keywords" content="Multi-dimensional Transforms (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="What-FFTW-Really-Computes.html" rel="up" title="What FFTW Really Computes">
<link href="Multi_002dthreaded-FFTW.html" rel="next" title="Multi-threaded FFTW">
<link href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html" rel="prev" title="1d Discrete Hartley Transforms (DHTs)">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Multi_002ddimensional-Transforms"></span><div class="header">
<p>
Previous: <a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html" accesskey="p" rel="prev">1d Discrete Hartley Transforms (DHTs)</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Multi_002ddimensional-Transforms-1"></span><h4 class="subsection">4.8.6 Multi-dimensional Transforms</h4>
<p>The multi-dimensional transforms of FFTW, in general, compute simply the
separable product of the given 1d transform along each dimension of the
array. Since each of these transforms is unnormalized, computing the
forward followed by the backward/inverse multi-dimensional transform
will result in the original array scaled by the product of the
normalization factors for each dimension (e.g. the product of the
dimension sizes, for a multi-dimensional DFT).
</p>
<span id="index-r2c-3"></span>
<p>The definition of FFTW&rsquo;s multi-dimensional DFT of real data (r2c)
deserves special attention. In this case, we logically compute the full
multi-dimensional DFT of the input data; since the input data are purely
real, the output data have the Hermitian symmetry and therefore only one
non-redundant half need be stored. More specifically, for an n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
multi-dimensional real-input DFT, the full (logical) complex output array
<i>Y</i>[<i>k</i><sub>0</sub>, <i>k</i><sub>1</sub>, ...,
<i>k</i><sub><i>d-1</i></sub>]
has the symmetry:
<i>Y</i>[<i>k</i><sub>0</sub>, <i>k</i><sub>1</sub>, ...,
<i>k</i><sub><i>d-1</i></sub>] = <i>Y</i>[<i>n</i><sub>0</sub> -
<i>k</i><sub>0</sub>, <i>n</i><sub>1</sub> - <i>k</i><sub>1</sub>, ...,
<i>n</i><sub><i>d-1</i></sub> - <i>k</i><sub><i>d-1</i></sub>]<sup>*</sup>
(where each dimension is periodic). Because of this symmetry, we only
store the
<i>k</i><sub><i>d-1</i></sub> = 0...<i>n</i><sub><i>d-1</i></sub>/2+1
elements of the <em>last</em> dimension (division by <em>2</em> 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 <a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a>.
</p>
<p>The multi-dimensional c2r transform is simply the unnormalized inverse
of the r2c transform. i.e. it is the same as FFTW&rsquo;s complex backward
multi-dimensional DFT, operating on a Hermitian input array in the
peculiar format mentioned above and outputting a real array (since the
DFT output is purely real).
</p>
<p>We should remind the user that the separable product of 1d transforms
along each dimension, as computed by FFTW, is not always the same thing
as the usual multi-dimensional transform. A multi-dimensional
<code>R2HC</code> (or <code>HC2R</code>) 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 <a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a>. Likewise, FFTW&rsquo;s multidimensional
<code>FFTW_DHT</code> r2r transform is not the same thing as the logical
multi-dimensional discrete Hartley transform defined in the literature,
as discussed in <a href="The-Discrete-Hartley-Transform.html">The Discrete Hartley Transform</a>.
</p>
<hr>
<div class="header">
<p>
Previous: <a href="1d-Discrete-Hartley-Transforms-_0028DHTs_0029.html" accesskey="p" rel="prev">1d Discrete Hartley Transforms (DHTs)</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

108
fftw-3.3.10/doc/html/Multi_002dthreaded-FFTW.html Normal file
View File

@@ -0,0 +1,108 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Multi-threaded FFTW (FFTW 3.3.10)</title>
<meta name="description" content="Multi-threaded FFTW (FFTW 3.3.10)">
<meta name="keywords" content="Multi-threaded FFTW (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="Installation-and-Supported-Hardware_002fSoftware.html" rel="next" title="Installation and Supported Hardware/Software">
<link href="Multi_002ddimensional-Transforms.html" rel="prev" title="Multi-dimensional Transforms">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Multi_002dthreaded-FFTW"></span><div class="header">
<p>
Next: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="n" rel="next">Distributed-memory FFTW with MPI</a>, Previous: <a href="FFTW-Reference.html" accesskey="p" rel="prev">FFTW Reference</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Multi_002dthreaded-FFTW-1"></span><h2 class="chapter">5 Multi-threaded FFTW</h2>
<span id="index-parallel-transform"></span>
<p>In this chapter we document the parallel FFTW routines for
shared-memory parallel hardware. These routines, which support
parallel one- and multi-dimensional transforms of both real and
complex data, are the easiest way to take advantage of multiple
processors with FFTW. They work just like the corresponding
uniprocessor transform routines, except that you have an extra
initialization routine to call, and there is a routine to set the
number of threads to employ. Any program that uses the uniprocessor
FFTW can therefore be trivially modified to use the multi-threaded
FFTW.
</p>
<p>A shared-memory machine is one in which all CPUs can directly access
the same main memory, and such machines are now common due to the
ubiquity of multi-core CPUs. FFTW&rsquo;s multi-threading support allows
you to utilize these additional CPUs transparently from a single
program. However, this does not necessarily translate into
performance gains&mdash;when multiple threads/CPUs are employed, there is
an overhead required for synchronization that may outweigh the
computatational parallelism. Therefore, you can only benefit from
threads if your problem is sufficiently large.
<span id="index-shared_002dmemory"></span>
<span id="index-threads"></span>
</p>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Installation-and-Supported-Hardware_002fSoftware.html" accesskey="1">Installation and Supported Hardware/Software</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Usage-of-Multi_002dthreaded-FFTW.html" accesskey="2">Usage of Multi-threaded FFTW</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="How-Many-Threads-to-Use_003f.html" accesskey="3">How Many Threads to Use?</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Thread-safety.html" accesskey="4">Thread safety</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

193
fftw-3.3.10/doc/html/New_002darray-Execute-Functions.html Normal file
View File

@@ -0,0 +1,193 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>New-array Execute Functions (FFTW 3.3.10)</title>
<meta name="description" content="New-array Execute Functions (FFTW 3.3.10)">
<meta name="keywords" content="New-array Execute Functions (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="FFTW-Reference.html" rel="up" title="FFTW Reference">
<link href="Wisdom.html" rel="next" title="Wisdom">
<link href="64_002dbit-Guru-Interface.html" rel="prev" title="64-bit Guru Interface">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="New_002darray-Execute-Functions"></span><div class="header">
<p>
Next: <a href="Wisdom.html" accesskey="n" rel="next">Wisdom</a>, Previous: <a href="Guru-Interface.html" accesskey="p" rel="prev">Guru Interface</a>, Up: <a href="FFTW-Reference.html" accesskey="u" rel="up">FFTW Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="New_002darray-Execute-Functions-1"></span><h3 class="section">4.6 New-array Execute Functions</h3>
<span id="index-execute-2"></span>
<span id="index-new_002darray-execution"></span>
<p>Normally, one executes a plan for the arrays with which the plan was
created, by calling <code>fftw_execute(plan)</code> as described in <a href="Using-Plans.html">Using Plans</a>.
<span id="index-fftw_005fexecute-2"></span>
However, it is possible for sophisticated users to apply a given plan
to a <em>different</em> array using the &ldquo;new-array execute&rdquo; functions
detailed below, provided that the following conditions are met:
</p>
<ul>
<li> The array size, strides, etcetera are the same (since those are set by
the plan).
</li><li> The input and output arrays are the same (in-place) or different
(out-of-place) if the plan was originally created to be in-place or
out-of-place, respectively.
</li><li> For split arrays, the separations between the real and imaginary
parts, <code>ii-ri</code> and <code>io-ro</code>, are the same as they were for
the input and output arrays when the plan was created. (This
condition is automatically satisfied for interleaved arrays.)
</li><li> The <em>alignment</em> of the new input/output arrays is the same as that
of the input/output arrays when the plan was created, unless the plan
was created with the <code>FFTW_UNALIGNED</code> flag.
<span id="index-FFTW_005fUNALIGNED-1"></span>
Here, the alignment is a platform-dependent quantity (for example, it is
the address modulo 16 if SSE SIMD instructions are used, but the address
modulo 4 for non-SIMD single-precision FFTW on the same machine). In
general, only arrays allocated with <code>fftw_malloc</code> are guaranteed to
be equally aligned (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>).
</li></ul>
<span id="index-alignment-2"></span>
<p>The alignment issue is especially critical, because if you don&rsquo;t use
<code>fftw_malloc</code> then you may have little control over the alignment
of arrays in memory. For example, neither the C++ <code>new</code> function
nor the Fortran <code>allocate</code> statement provide strong enough
guarantees about data alignment. If you don&rsquo;t use <code>fftw_malloc</code>,
therefore, you probably have to use <code>FFTW_UNALIGNED</code> (which
disables most SIMD support). If possible, it is probably better for
you to simply create multiple plans (creating a new plan is quick once
one exists for a given size), or better yet re-use the same array for
your transforms.
</p>
<span id="index-fftw_005falignment_005fof-1"></span>
<p>For rare circumstances in which you cannot control the alignment of
allocated memory, but wish to determine where a given array is
aligned like the original array for which a plan was created, you can
use the <code>fftw_alignment_of</code> function:
</p><div class="example">
<pre class="example">int fftw_alignment_of(double *p);
</pre></div>
<p>Two arrays have equivalent alignment (for the purposes of applying a
plan) if and only if <code>fftw_alignment_of</code> returns the same value
for the corresponding pointers to their data (typecast to <code>double*</code>
if necessary).
</p>
<p>If you are tempted to use the new-array execute interface because you
want to transform a known bunch of arrays of the same size, you should
probably go use the advanced interface instead (see <a href="Advanced-Interface.html">Advanced Interface</a>)).
</p>
<p>The new-array execute functions are:
</p>
<div class="example">
<pre class="example">void fftw_execute_dft(
const fftw_plan p,
fftw_complex *in, fftw_complex *out);
void fftw_execute_split_dft(
const fftw_plan p,
double *ri, double *ii, double *ro, double *io);
void fftw_execute_dft_r2c(
const fftw_plan p,
double *in, fftw_complex *out);
void fftw_execute_split_dft_r2c(
const fftw_plan p,
double *in, double *ro, double *io);
void fftw_execute_dft_c2r(
const fftw_plan p,
fftw_complex *in, double *out);
void fftw_execute_split_dft_c2r(
const fftw_plan p,
double *ri, double *ii, double *out);
void fftw_execute_r2r(
const fftw_plan p,
double *in, double *out);
</pre></div>
<span id="index-fftw_005fexecute_005fdft"></span>
<span id="index-fftw_005fexecute_005fsplit_005fdft"></span>
<span id="index-fftw_005fexecute_005fdft_005fr2c"></span>
<span id="index-fftw_005fexecute_005fsplit_005fdft_005fr2c"></span>
<span id="index-fftw_005fexecute_005fdft_005fc2r"></span>
<span id="index-fftw_005fexecute_005fsplit_005fdft_005fc2r"></span>
<span id="index-fftw_005fexecute_005fr2r"></span>
<p>These execute the <code>plan</code> to compute the corresponding transform on
the input/output arrays specified by the subsequent arguments. The
input/output array arguments have the same meanings as the ones passed
to the guru planner routines in the preceding sections. The <code>plan</code>
is not modified, and these routines can be called as many times as
desired, or intermixed with calls to the ordinary <code>fftw_execute</code>.
</p>
<p>The <code>plan</code> <em>must</em> have been created for the transform type
corresponding to the execute function, e.g. it must be a complex-DFT
plan for <code>fftw_execute_dft</code>. Any of the planner routines for that
transform type, from the basic to the guru interface, could have been
used to create the plan, however.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Wisdom.html" accesskey="n" rel="next">Wisdom</a>, Previous: <a href="Guru-Interface.html" accesskey="p" rel="prev">Guru Interface</a>, Up: <a href="FFTW-Reference.html" accesskey="u" rel="up">FFTW Reference</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

173
fftw-3.3.10/doc/html/One_002dDimensional-DFTs-of-Real-Data.html Normal file
View File

@@ -0,0 +1,173 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>One-Dimensional DFTs of Real Data (FFTW 3.3.10)</title>
<meta name="description" content="One-Dimensional DFTs of Real Data (FFTW 3.3.10)">
<meta name="keywords" content="One-Dimensional DFTs of Real Data (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Tutorial.html" rel="up" title="Tutorial">
<link href="Multi_002dDimensional-DFTs-of-Real-Data.html" rel="next" title="Multi-Dimensional DFTs of Real Data">
<link href="Complex-Multi_002dDimensional-DFTs.html" rel="prev" title="Complex Multi-Dimensional DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="One_002dDimensional-DFTs-of-Real-Data"></span><div class="header">
<p>
Next: <a href="Multi_002dDimensional-DFTs-of-Real-Data.html" accesskey="n" rel="next">Multi-Dimensional DFTs of Real Data</a>, Previous: <a href="Complex-Multi_002dDimensional-DFTs.html" accesskey="p" rel="prev">Complex Multi-Dimensional DFTs</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="One_002dDimensional-DFTs-of-Real-Data-1"></span><h3 class="section">2.3 One-Dimensional DFTs of Real Data</h3>
<p>In many practical applications, the input data <code>in[i]</code> are purely
real numbers, in which case the DFT output satisfies the &ldquo;Hermitian&rdquo;
<span id="index-Hermitian"></span>
redundancy: <code>out[i]</code> is the conjugate of <code>out[n-i]</code>. It is
possible to take advantage of these circumstances in order to achieve
roughly a factor of two improvement in both speed and memory usage.
</p>
<p>In exchange for these speed and space advantages, the user sacrifices
some of the simplicity of FFTW&rsquo;s complex transforms. First of all, the
input and output arrays are of <em>different sizes and types</em>: the
input is <code>n</code> real numbers, while the output is <code>n/2+1</code>
complex numbers (the non-redundant outputs); this also requires slight
&ldquo;padding&rdquo; of the input array for
<span id="index-padding"></span>
in-place transforms. Second, the inverse transform (complex to real)
has the side-effect of <em>overwriting its input array</em>, by default.
Neither of these inconveniences should pose a serious problem for
users, but it is important to be aware of them.
</p>
<p>The routines to perform real-data transforms are almost the same as
those for complex transforms: you allocate arrays of <code>double</code>
and/or <code>fftw_complex</code> (preferably using <code>fftw_malloc</code> or
<code>fftw_alloc_complex</code>), create an <code>fftw_plan</code>, execute it as
many times as you want with <code>fftw_execute(plan)</code>, and clean up
with <code>fftw_destroy_plan(plan)</code> (and <code>fftw_free</code>). The only
differences are that the input (or output) is of type <code>double</code>
and there are new routines to create the plan. In one dimension:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_plan_dft_r2c_1d(int n, double *in, fftw_complex *out,
unsigned flags);
fftw_plan fftw_plan_dft_c2r_1d(int n, fftw_complex *in, double *out,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft_005fr2c_005f1d"></span>
<span id="index-fftw_005fplan_005fdft_005fc2r_005f1d"></span>
<p>for the real input to complex-Hermitian output (<em>r2c</em>) and
complex-Hermitian input to real output (<em>c2r</em>) transforms.
<span id="index-r2c"></span>
<span id="index-c2r"></span>
Unlike the complex DFT planner, there is no <code>sign</code> argument.
Instead, r2c DFTs are always <code>FFTW_FORWARD</code> and c2r DFTs are
always <code>FFTW_BACKWARD</code>.
<span id="index-FFTW_005fFORWARD-1"></span>
<span id="index-FFTW_005fBACKWARD-1"></span>
(For single/long-double precision
<code>fftwf</code> and <code>fftwl</code>, <code>double</code> should be replaced by
<code>float</code> and <code>long double</code>, respectively.)
<span id="index-precision-1"></span>
</p>
<p>Here, <code>n</code> is the &ldquo;logical&rdquo; size of the DFT, not necessarily the
physical size of the array. In particular, the real (<code>double</code>)
array has <code>n</code> elements, while the complex (<code>fftw_complex</code>)
array has <code>n/2+1</code> elements (where the division is rounded down).
For an in-place transform,
<span id="index-in_002dplace-1"></span>
<code>in</code> and <code>out</code> are aliased to the same array, which must be
big enough to hold both; so, the real array would actually have
<code>2*(n/2+1)</code> elements, where the elements beyond the first
<code>n</code> are unused padding. (Note that this is very different from
the concept of &ldquo;zero-padding&rdquo; a transform to a larger length, which
changes the logical size of the DFT by actually adding new input
data.) The <em>k</em>th element of the complex array is exactly the
same as the <em>k</em>th element of the corresponding complex DFT. All
positive <code>n</code> are supported; products of small factors are most
efficient, but an <i>O</i>(<i>n</i>&nbsp;log&nbsp;<i>n</i>)
algorithm is used even for prime sizes.
</p>
<p>As noted above, the c2r transform destroys its input array even for
out-of-place transforms. This can be prevented, if necessary, by
including <code>FFTW_PRESERVE_INPUT</code> in the <code>flags</code>, with
unfortunately some sacrifice in performance.
<span id="index-flags-1"></span>
<span id="index-FFTW_005fPRESERVE_005fINPUT"></span>
This flag is also not currently supported for multi-dimensional real
DFTs (next section).
</p>
<p>Readers familiar with DFTs of real data will recall that the 0th (the
&ldquo;DC&rdquo;) and <code>n/2</code>-th (the &ldquo;Nyquist&rdquo; frequency, when <code>n</code> is
even) elements of the complex output are purely real. Some
implementations therefore store the Nyquist element where the DC
imaginary part would go, in order to make the input and output arrays
the same size. Such packing, however, does not generalize well to
multi-dimensional transforms, and the space savings are miniscule in
any case; FFTW does not support it.
</p>
<p>An alternative interface for one-dimensional r2c and c2r DFTs can be
found in the &lsquo;<samp>r2r</samp>&rsquo; interface (see <a href="The-Halfcomplex_002dformat-DFT.html">The Halfcomplex-format DFT</a>), with &ldquo;halfcomplex&rdquo;-format output that <em>is</em> the same size
(and type) as the input array.
<span id="index-halfcomplex-format"></span>
That interface, although it is not very useful for multi-dimensional
transforms, may sometimes yield better performance.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Multi_002dDimensional-DFTs-of-Real-Data.html" accesskey="n" rel="next">Multi-Dimensional DFTs of Real Data</a>, Previous: <a href="Complex-Multi_002dDimensional-DFTs.html" accesskey="p" rel="prev">Complex Multi-Dimensional DFTs</a>, Up: <a href="Tutorial.html" accesskey="u" rel="up">Tutorial</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

128
fftw-3.3.10/doc/html/One_002ddimensional-distributions.html Normal file
View File

@@ -0,0 +1,128 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>One-dimensional distributions (FFTW 3.3.10)</title>
<meta name="description" content="One-dimensional distributions (FFTW 3.3.10)">
<meta name="keywords" content="One-dimensional distributions (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="MPI-Data-Distribution.html" rel="up" title="MPI Data Distribution">
<link href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html" rel="next" title="Multi-dimensional MPI DFTs of Real Data">
<link href="Transposed-distributions.html" rel="prev" title="Transposed distributions">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="One_002ddimensional-distributions"></span><div class="header">
<p>
Previous: <a href="Transposed-distributions.html" accesskey="p" rel="prev">Transposed distributions</a>, Up: <a href="MPI-Data-Distribution.html" accesskey="u" rel="up">MPI Data Distribution</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="One_002ddimensional-distributions-1"></span><h4 class="subsection">6.4.4 One-dimensional distributions</h4>
<p>For one-dimensional distributed DFTs using FFTW, matters are slightly
more complicated because the data distribution is more closely tied to
how the algorithm works. In particular, you can no longer pass an
arbitrary block size and must accept FFTW&rsquo;s default; also, the block
sizes may be different for input and output. Also, the data
distribution depends on the flags and transform direction, in order
for forward and backward transforms to work correctly.
</p>
<div class="example">
<pre class="example">ptrdiff_t fftw_mpi_local_size_1d(ptrdiff_t n0, MPI_Comm comm,
int sign, unsigned flags,
ptrdiff_t *local_ni, ptrdiff_t *local_i_start,
ptrdiff_t *local_no, ptrdiff_t *local_o_start);
</pre></div>
<span id="index-fftw_005fmpi_005flocal_005fsize_005f1d"></span>
<p>This function computes the data distribution for a 1d transform of
size <code>n0</code> with the given transform <code>sign</code> and <code>flags</code>.
Both input and output data use block distributions. The input on the
current process will consist of <code>local_ni</code> numbers starting at
index <code>local_i_start</code>; e.g. if only a single process is used,
then <code>local_ni</code> will be <code>n0</code> and <code>local_i_start</code> will
be <code>0</code>. Similarly for the output, with <code>local_no</code> numbers
starting at index <code>local_o_start</code>. The return value of
<code>fftw_mpi_local_size_1d</code> will be the total number of elements to
allocate on the current process (which might be slightly larger than
the local size due to intermediate steps in the algorithm).
</p>
<p>As mentioned above (see <a href="Load-balancing.html">Load balancing</a>), the data will be divided
equally among the processes if <code>n0</code> is divisible by the
<em>square</em> of the number of processes. In this case,
<code>local_ni</code> will equal <code>local_no</code>. Otherwise, they may be
different.
</p>
<p>For some applications, such as convolutions, the order of the output
data is irrelevant. In this case, performance can be improved by
specifying that the output data be stored in an FFTW-defined
&ldquo;scrambled&rdquo; format. (In particular, this is the analogue of
transposed output in the multidimensional case: scrambled output saves
a communications step.) If you pass <code>FFTW_MPI_SCRAMBLED_OUT</code> in
the flags, then the output is stored in this (undocumented) scrambled
order. Conversely, to perform the inverse transform of data in
scrambled order, pass the <code>FFTW_MPI_SCRAMBLED_IN</code> flag.
<span id="index-FFTW_005fMPI_005fSCRAMBLED_005fOUT"></span>
<span id="index-FFTW_005fMPI_005fSCRAMBLED_005fIN"></span>
</p>
<p>In MPI FFTW, only composite sizes <code>n0</code> can be parallelized; we
have not yet implemented a parallel algorithm for large prime sizes.
</p>
<hr>
<div class="header">
<p>
Previous: <a href="Transposed-distributions.html" accesskey="p" rel="prev">Transposed distributions</a>, Up: <a href="MPI-Data-Distribution.html" accesskey="u" rel="up">MPI Data Distribution</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

83
fftw-3.3.10/doc/html/Other-Important-Topics.html Normal file
View File

@@ -0,0 +1,83 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Other Important Topics (FFTW 3.3.10)</title>
<meta name="description" content="Other Important Topics (FFTW 3.3.10)">
<meta name="keywords" content="Other Important Topics (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="index.html" rel="up" title="Top">
<link href="SIMD-alignment-and-fftw_005fmalloc.html" rel="next" title="SIMD alignment and fftw_malloc">
<link href="The-Discrete-Hartley-Transform.html" rel="prev" title="The Discrete Hartley Transform">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Other-Important-Topics"></span><div class="header">
<p>
Next: <a href="FFTW-Reference.html" accesskey="n" rel="next">FFTW Reference</a>, Previous: <a href="Tutorial.html" accesskey="p" rel="prev">Tutorial</a>, Up: <a href="index.html" accesskey="u" rel="up">Top</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Other-Important-Topics-1"></span><h2 class="chapter">3 Other Important Topics</h2>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="SIMD-alignment-and-fftw_005fmalloc.html" accesskey="1">SIMD alignment and fftw_malloc</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Multi_002ddimensional-Array-Format.html" accesskey="2">Multi-dimensional Array Format</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Words-of-Wisdom_002dSaving-Plans.html" accesskey="3">Words of Wisdom-Saving Plans</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
<tr><td align="left" valign="top">&bull; <a href="Caveats-in-Using-Wisdom.html" accesskey="4">Caveats in Using Wisdom</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
</body>
</html>

121
fftw-3.3.10/doc/html/Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms.html Normal file
View File

@@ -0,0 +1,121 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Other Multi-dimensional Real-data MPI Transforms (FFTW 3.3.10)</title>
<meta name="description" content="Other Multi-dimensional Real-data MPI Transforms (FFTW 3.3.10)">
<meta name="keywords" content="Other Multi-dimensional Real-data MPI Transforms (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Distributed_002dmemory-FFTW-with-MPI.html" rel="up" title="Distributed-memory FFTW with MPI">
<link href="FFTW-MPI-Transposes.html" rel="next" title="FFTW MPI Transposes">
<link href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html" rel="prev" title="Multi-dimensional MPI DFTs of Real Data">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Other-Multi_002ddimensional-Real_002ddata-MPI-Transforms"></span><div class="header">
<p>
Next: <a href="FFTW-MPI-Transposes.html" accesskey="n" rel="next">FFTW MPI Transposes</a>, Previous: <a href="Multi_002ddimensional-MPI-DFTs-of-Real-Data.html" accesskey="p" rel="prev">Multi-dimensional MPI DFTs of Real Data</a>, Up: <a href="Distributed_002dmemory-FFTW-with-MPI.html" accesskey="u" rel="up">Distributed-memory FFTW with MPI</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Other-multi_002ddimensional-Real_002dData-MPI-Transforms"></span><h3 class="section">6.6 Other multi-dimensional Real-Data MPI Transforms</h3>
<span id="index-r2r-3"></span>
<p>FFTW&rsquo;s MPI interface also supports multi-dimensional &lsquo;<samp>r2r</samp>&rsquo;
transforms of all kinds supported by the serial interface
(e.g. discrete cosine and sine transforms, discrete Hartley
transforms, etc.). Only multi-dimensional &lsquo;<samp>r2r</samp>&rsquo; transforms, not
one-dimensional transforms, are currently parallelized.
</p>
<span id="index-fftw_005fr2r_005fkind-1"></span>
<p>These are used much like the multidimensional complex DFTs discussed
above, except that the data is real rather than complex, and one needs
to pass an r2r transform kind (<code>fftw_r2r_kind</code>) for each
dimension as in the serial FFTW (see <a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a>).
</p>
<p>For example, one might perform a two-dimensional L&nbsp;&times;&nbsp;M
that is
an REDFT10 (DCT-II) in the first dimension and an RODFT10 (DST-II) in
the second dimension with code like:
</p>
<div class="example">
<pre class="example"> const ptrdiff_t L = ..., M = ...;
fftw_plan plan;
double *data;
ptrdiff_t alloc_local, local_n0, local_0_start, i, j;
/* <span class="roman">get local data size and allocate</span> */
alloc_local = fftw_mpi_local_size_2d(L, M, MPI_COMM_WORLD,
&amp;local_n0, &amp;local_0_start);
data = fftw_alloc_real(alloc_local);
/* <span class="roman">create plan for in-place REDFT10 x RODFT10</span> */
plan = fftw_mpi_plan_r2r_2d(L, M, data, data, MPI_COMM_WORLD,
FFTW_REDFT10, FFTW_RODFT10, FFTW_MEASURE);
/* <span class="roman">initialize data to some function</span> my_function(x,y) */
for (i = 0; i &lt; local_n0; ++i) for (j = 0; j &lt; M; ++j)
data[i*M + j] = my_function(local_0_start + i, j);
/* <span class="roman">compute transforms, in-place, as many times as desired</span> */
fftw_execute(plan);
fftw_destroy_plan(plan);
</pre></div>
<span id="index-fftw_005falloc_005freal-3"></span>
<p>Notice that we use the same &lsquo;<samp>local_size</samp>&rsquo; functions as we did for
complex data, only now we interpret the sizes in terms of real rather
than complex values, and correspondingly use <code>fftw_alloc_real</code>.
</p>
</body>
</html>

162
fftw-3.3.10/doc/html/Overview-of-Fortran-interface.html Normal file
View File

@@ -0,0 +1,162 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Overview of Fortran interface (FFTW 3.3.10)</title>
<meta name="description" content="Overview of Fortran interface (FFTW 3.3.10)">
<meta name="keywords" content="Overview of Fortran interface (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="up" title="Calling FFTW from Modern Fortran">
<link href="Extended-and-quadruple-precision-in-Fortran.html" rel="next" title="Extended and quadruple precision in Fortran">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="prev" title="Calling FFTW from Modern Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Overview-of-Fortran-interface"></span><div class="header">
<p>
Next: <a href="Reversing-array-dimensions.html" accesskey="n" rel="next">Reversing array dimensions</a>, Previous: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="p" rel="prev">Calling FFTW from Modern Fortran</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Overview-of-Fortran-interface-1"></span><h3 class="section">7.1 Overview of Fortran interface</h3>
<p>FFTW provides a file <code>fftw3.f03</code> that defines Fortran 2003
interfaces for all of its C routines, except for the MPI routines
described elsewhere, which can be found in the same directory as
<code>fftw3.h</code> (the C header file). In any Fortran subroutine where
you want to use FFTW functions, you should begin with:
</p>
<span id="index-iso_005fc_005fbinding-1"></span>
<div class="example">
<pre class="example"> use, intrinsic :: iso_c_binding
include 'fftw3.f03'
</pre></div>
<p>This includes the interface definitions and the standard
<code>iso_c_binding</code> module (which defines the equivalents of C
types). You can also put the FFTW functions into a module if you
prefer (see <a href="Defining-an-FFTW-module.html">Defining an FFTW module</a>).
</p>
<p>At this point, you can now call anything in the FFTW C interface
directly, almost exactly as in C other than minor changes in syntax.
For example:
</p>
<span id="index-fftw_005fplan_005fdft_005f2d-2"></span>
<span id="index-fftw_005fexecute_005fdft-2"></span>
<span id="index-fftw_005fdestroy_005fplan-3"></span>
<div class="example">
<pre class="example"> type(C_PTR) :: plan
complex(C_DOUBLE_COMPLEX), dimension(1024,1000) :: in, out
plan = fftw_plan_dft_2d(1000,1024, in,out, FFTW_FORWARD,FFTW_ESTIMATE)
...
call fftw_execute_dft(plan, in, out)
...
call fftw_destroy_plan(plan)
</pre></div>
<p>A few important things to keep in mind are:
</p>
<ul>
<li> <span id="index-fftw_005fcomplex-2"></span>
<span id="index-C_005fPTR"></span>
<span id="index-C_005fINT"></span>
<span id="index-C_005fDOUBLE"></span>
<span id="index-C_005fDOUBLE_005fCOMPLEX"></span>
FFTW plans are <code>type(C_PTR)</code>. Other C types are mapped in the
obvious way via the <code>iso_c_binding</code> standard: <code>int</code> turns
into <code>integer(C_INT)</code>, <code>fftw_complex</code> turns into
<code>complex(C_DOUBLE_COMPLEX)</code>, <code>double</code> turns into
<code>real(C_DOUBLE)</code>, and so on. See <a href="FFTW-Fortran-type-reference.html">FFTW Fortran type reference</a>.
</li><li> Functions in C become functions in Fortran if they have a return value,
and subroutines in Fortran otherwise.
</li><li> The ordering of the Fortran array dimensions must be <em>reversed</em>
when they are passed to the FFTW plan creation, thanks to differences
in array indexing conventions (see <a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>). This is <em>unlike</em> the legacy Fortran interface
(see <a href="Fortran_002dinterface-routines.html">Fortran-interface routines</a>), which reversed the dimensions
for you. See <a href="Reversing-array-dimensions.html">Reversing array dimensions</a>.
</li><li> <span id="index-alignment-4"></span>
<span id="index-SIMD-2"></span>
Using ordinary Fortran array declarations like this works, but may
yield suboptimal performance because the data may not be not aligned
to exploit SIMD instructions on modern proessors (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>). Better performance will often be obtained
by allocating with &lsquo;<samp>fftw_alloc</samp>&rsquo;. See <a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a>.
</li><li> <span id="index-fftw_005fexecute-5"></span>
Similar to the legacy Fortran interface (see <a href="FFTW-Execution-in-Fortran.html">FFTW Execution in Fortran</a>), we currently recommend <em>not</em> using <code>fftw_execute</code>
but rather using the more specialized functions like
<code>fftw_execute_dft</code> (see <a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a>).
However, you should execute the plan on the <code>same arrays</code> as the
ones for which you created the plan, unless you are especially
careful. See <a href="Plan-execution-in-Fortran.html">Plan execution in Fortran</a>. To prevent
you from using <code>fftw_execute</code> by mistake, the <code>fftw3.f03</code>
file does not provide an <code>fftw_execute</code> interface declaration.
</li><li> <span id="index-flags-8"></span>
Multiple planner flags are combined with <code>ior</code> (equivalent to &lsquo;<samp>|</samp>&rsquo; in C). e.g. <code>FFTW_MEASURE | FFTW_DESTROY_INPUT</code> becomes <code>ior(FFTW_MEASURE, FFTW_DESTROY_INPUT)</code>. (You can also use &lsquo;<samp>+</samp>&rsquo; as long as you don&rsquo;t try to include a given flag more than once.)
</li></ul>
<table class="menu" border="0" cellspacing="0">
<tr><td align="left" valign="top">&bull; <a href="Extended-and-quadruple-precision-in-Fortran.html" accesskey="1">Extended and quadruple precision in Fortran</a></td><td>&nbsp;&nbsp;</td><td align="left" valign="top">
</td></tr>
</table>
<hr>
<div class="header">
<p>
Next: <a href="Reversing-array-dimensions.html" accesskey="n" rel="next">Reversing array dimensions</a>, Previous: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="p" rel="prev">Calling FFTW from Modern Fortran</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

138
fftw-3.3.10/doc/html/Plan-execution-in-Fortran.html Normal file
View File

@@ -0,0 +1,138 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Plan execution in Fortran (FFTW 3.3.10)</title>
<meta name="description" content="Plan execution in Fortran (FFTW 3.3.10)">
<meta name="keywords" content="Plan execution in Fortran (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="up" title="Calling FFTW from Modern Fortran">
<link href="Allocating-aligned-memory-in-Fortran.html" rel="next" title="Allocating aligned memory in Fortran">
<link href="FFTW-Fortran-type-reference.html" rel="prev" title="FFTW Fortran type reference">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Plan-execution-in-Fortran"></span><div class="header">
<p>
Next: <a href="Allocating-aligned-memory-in-Fortran.html" accesskey="n" rel="next">Allocating aligned memory in Fortran</a>, Previous: <a href="FFTW-Fortran-type-reference.html" accesskey="p" rel="prev">FFTW Fortran type reference</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Plan-execution-in-Fortran-1"></span><h3 class="section">7.4 Plan execution in Fortran</h3>
<p>In C, in order to use a plan, one normally calls <code>fftw_execute</code>,
which executes the plan to perform the transform on the input/output
arrays passed when the plan was created (see <a href="Using-Plans.html">Using Plans</a>). The
corresponding subroutine call in modern Fortran is:
</p><div class="example">
<pre class="example"> call fftw_execute(plan)
</pre></div>
<span id="index-fftw_005fexecute-6"></span>
<p>However, we have had reports that this causes problems with some
recent optimizing Fortran compilers. The problem is, because the
input/output arrays are not passed as explicit arguments to
<code>fftw_execute</code>, the semantics of Fortran (unlike C) allow the
compiler to assume that the input/output arrays are not changed by
<code>fftw_execute</code>. As a consequence, certain compilers end up
repositioning the call to <code>fftw_execute</code>, assuming incorrectly
that it does nothing to the arrays.
</p>
<p>There are various workarounds to this, but the safest and simplest
thing is to not use <code>fftw_execute</code> in Fortran. Instead, use the
functions described in <a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a>, which take
the input/output arrays as explicit arguments. For example, if the
plan is for a complex-data DFT and was created for the arrays
<code>in</code> and <code>out</code>, you would do:
</p><div class="example">
<pre class="example"> call fftw_execute_dft(plan, in, out)
</pre></div>
<span id="index-fftw_005fexecute_005fdft-3"></span>
<p>There are a few things to be careful of, however:
</p>
<ul>
<li> <span id="index-fftw_005fexecute_005fdft_005fr2c-2"></span>
<span id="index-fftw_005fexecute_005fdft_005fc2r-1"></span>
<span id="index-fftw_005fexecute_005fr2r-1"></span>
You must use the correct type of execute function, matching the way
the plan was created. Complex DFT plans should use
<code>fftw_execute_dft</code>, Real-input (r2c) DFT plans should use use
<code>fftw_execute_dft_r2c</code>, and real-output (c2r) DFT plans should
use <code>fftw_execute_dft_c2r</code>. The various r2r plans should use
<code>fftw_execute_r2r</code>. Fortunately, if you use the wrong one you
will get a compile-time type-mismatch error (unlike legacy Fortran).
</li><li> You should normally pass the same input/output arrays that were used when
creating the plan. This is always safe.
</li><li> <em>If</em> you pass <em>different</em> input/output arrays compared to
those used when creating the plan, you must abide by all the
restrictions of the new-array execute functions (see <a href="New_002darray-Execute-Functions.html">New-array Execute Functions</a>). The most tricky of these is the
requirement that the new arrays have the same alignment as the
original arrays; the best (and possibly only) way to guarantee this
is to use the &lsquo;<samp>fftw_alloc</samp>&rsquo; functions to allocate your arrays (see <a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a>). Alternatively, you can
use the <code>FFTW_UNALIGNED</code> flag when creating the
plan, in which case the plan does not depend on the alignment, but
this may sacrifice substantial performance on architectures (like x86)
with SIMD instructions (see <a href="SIMD-alignment-and-fftw_005fmalloc.html">SIMD alignment and fftw_malloc</a>).
<span id="index-FFTW_005fUNALIGNED-2"></span>
</li></ul>
<hr>
<div class="header">
<p>
Next: <a href="Allocating-aligned-memory-in-Fortran.html" accesskey="n" rel="next">Allocating aligned memory in Fortran</a>, Previous: <a href="FFTW-Fortran-type-reference.html" accesskey="p" rel="prev">FFTW Fortran type reference</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

204
fftw-3.3.10/doc/html/Planner-Flags.html Normal file
View File

@@ -0,0 +1,204 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Planner Flags (FFTW 3.3.10)</title>
<meta name="description" content="Planner Flags (FFTW 3.3.10)">
<meta name="keywords" content="Planner Flags (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Basic-Interface.html" rel="up" title="Basic Interface">
<link href="Real_002ddata-DFTs.html" rel="next" title="Real-data DFTs">
<link href="Complex-DFTs.html" rel="prev" title="Complex DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Planner-Flags"></span><div class="header">
<p>
Next: <a href="Real_002ddata-DFTs.html" accesskey="n" rel="next">Real-data DFTs</a>, Previous: <a href="Complex-DFTs.html" accesskey="p" rel="prev">Complex DFTs</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Planner-Flags-1"></span><h4 class="subsection">4.3.2 Planner Flags</h4>
<p>All of the planner routines in FFTW accept an integer <code>flags</code>
argument, which is a bitwise OR (&lsquo;<samp>|</samp>&rsquo;) of zero or more of the flag
constants defined below. These flags control the rigor (and time) of
the planning process, and can also impose (or lift) restrictions on the
type of transform algorithm that is employed.
</p>
<p><em>Important:</em> the planner overwrites the input array during
planning unless a saved plan (see <a href="Wisdom.html">Wisdom</a>) is available for that
problem, so you should initialize your input data after creating the
plan. The only exceptions to this are the <code>FFTW_ESTIMATE</code> and
<code>FFTW_WISDOM_ONLY</code> flags, as mentioned below.
</p>
<p>In all cases, if wisdom is available for the given problem that was
created with equal-or-greater planning rigor, then the more rigorous
wisdom is used. For example, in <code>FFTW_ESTIMATE</code> mode any available
wisdom is used, whereas in <code>FFTW_PATIENT</code> mode only wisdom created
in patient or exhaustive mode can be used. See <a href="Words-of-Wisdom_002dSaving-Plans.html">Words of Wisdom-Saving Plans</a>.
</p>
<span id="Planning_002drigor-flags"></span><h4 class="subsubheading">Planning-rigor flags</h4>
<ul>
<li> <span id="index-FFTW_005fESTIMATE-2"></span>
<code>FFTW_ESTIMATE</code> specifies that, instead of actual measurements of
different algorithms, a simple heuristic is used to pick a (probably
sub-optimal) plan quickly. With this flag, the input/output arrays are
not overwritten during planning.
</li><li> <span id="index-FFTW_005fMEASURE-2"></span>
<code>FFTW_MEASURE</code> tells FFTW to find an optimized plan by actually
<em>computing</em> several FFTs and measuring their execution time.
Depending on your machine, this can take some time (often a few
seconds). <code>FFTW_MEASURE</code> is the default planning option.
</li><li> <span id="index-FFTW_005fPATIENT-2"></span>
<code>FFTW_PATIENT</code> is like <code>FFTW_MEASURE</code>, but considers a wider
range of algorithms and often produces a &ldquo;more optimal&rdquo; plan
(especially for large transforms), but at the expense of several times
longer planning time (especially for large transforms).
</li><li> <span id="index-FFTW_005fEXHAUSTIVE-1"></span>
<code>FFTW_EXHAUSTIVE</code> is like <code>FFTW_PATIENT</code>, but considers an
even wider range of algorithms, including many that we think are
unlikely to be fast, to produce the most optimal plan but with a
substantially increased planning time.
</li><li> <span id="index-FFTW_005fWISDOM_005fONLY"></span>
<code>FFTW_WISDOM_ONLY</code> is a special planning mode in which the plan
is only created if wisdom is available for the given problem, and
otherwise a <code>NULL</code> plan is returned. This can be combined with
other flags, e.g. &lsquo;<samp>FFTW_WISDOM_ONLY | FFTW_PATIENT</samp>&rsquo; creates a
plan only if wisdom is available that was created in
<code>FFTW_PATIENT</code> or <code>FFTW_EXHAUSTIVE</code> mode. The
<code>FFTW_WISDOM_ONLY</code> flag is intended for users who need to detect
whether wisdom is available; for example, if wisdom is not available
one may wish to allocate new arrays for planning so that user data is
not overwritten.
</li></ul>
<span id="Algorithm_002drestriction-flags"></span><h4 class="subsubheading">Algorithm-restriction flags</h4>
<ul>
<li> <span id="index-FFTW_005fDESTROY_005fINPUT"></span>
<code>FFTW_DESTROY_INPUT</code> specifies that an out-of-place transform is
allowed to <em>overwrite its input</em> array with arbitrary data; this
can sometimes allow more efficient algorithms to be employed.
<span id="index-out_002dof_002dplace"></span>
</li><li> <span id="index-FFTW_005fPRESERVE_005fINPUT-1"></span>
<code>FFTW_PRESERVE_INPUT</code> specifies that an out-of-place transform must
<em>not change its input</em> array. This is ordinarily the
<em>default</em>, except for c2r and hc2r (i.e. complex-to-real)
transforms for which <code>FFTW_DESTROY_INPUT</code> is the default. In the
latter cases, passing <code>FFTW_PRESERVE_INPUT</code> will attempt to use
algorithms that do not destroy the input, at the expense of worse
performance; for multi-dimensional c2r transforms, however, no
input-preserving algorithms are implemented and the planner will return
<code>NULL</code> if one is requested.
<span id="index-c2r-1"></span>
<span id="index-hc2r-1"></span>
</li><li> <span id="index-FFTW_005fUNALIGNED"></span>
<span id="index-alignment-1"></span>
<span id="index-fftw_005fmalloc-4"></span>
<span id="index-fftw_005falignment_005fof"></span>
<code>FFTW_UNALIGNED</code> specifies that the algorithm may not impose any
unusual alignment requirements on the input/output arrays (i.e. no
SIMD may be used). This flag is normally <em>not necessary</em>, since
the planner automatically detects misaligned arrays. The only use for
this flag is if you want to use the new-array execute interface to
execute a given plan on a different array that may not be aligned like
the original. (Using <code>fftw_malloc</code> makes this flag unnecessary
even then. You can also use <code>fftw_alignment_of</code> to detect
whether two arrays are equivalently aligned.)
</li></ul>
<span id="Limiting-planning-time"></span><h4 class="subsubheading">Limiting planning time</h4>
<div class="example">
<pre class="example">extern void fftw_set_timelimit(double seconds);
</pre></div>
<span id="index-fftw_005fset_005ftimelimit"></span>
<p>This function instructs FFTW to spend at most <code>seconds</code> seconds
(approximately) in the planner. If <code>seconds ==
FFTW_NO_TIMELIMIT</code> (the default value, which is negative), then
planning time is unbounded. Otherwise, FFTW plans with a
progressively wider range of algorithms until the given time limit
is reached or the given range of algorithms is explored, returning the
best available plan.
<span id="index-FFTW_005fNO_005fTIMELIMIT"></span>
</p>
<p>For example, specifying <code>FFTW_PATIENT</code> first plans in
<code>FFTW_ESTIMATE</code> mode, then in <code>FFTW_MEASURE</code> mode, then
finally (time permitting) in <code>FFTW_PATIENT</code>. If
<code>FFTW_EXHAUSTIVE</code> is specified instead, the planner will further
progress to <code>FFTW_EXHAUSTIVE</code> mode.
</p>
<p>Note that the <code>seconds</code> argument specifies only a rough limit; in
practice, the planner may use somewhat more time if the time limit is
reached when the planner is in the middle of an operation that cannot
be interrupted. At the very least, the planner will complete planning
in <code>FFTW_ESTIMATE</code> mode (which is thus equivalent to a time limit
of 0).
</p>
<hr>
<div class="header">
<p>
Next: <a href="Real_002ddata-DFTs.html" accesskey="n" rel="next">Real-data DFTs</a>, Previous: <a href="Complex-DFTs.html" accesskey="p" rel="prev">Complex DFTs</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

113
fftw-3.3.10/doc/html/Precision.html Normal file
View File

@@ -0,0 +1,113 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Precision (FFTW 3.3.10)</title>
<meta name="description" content="Precision (FFTW 3.3.10)">
<meta name="keywords" content="Precision (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Data-Types-and-Files.html" rel="up" title="Data Types and Files">
<link href="Memory-Allocation.html" rel="next" title="Memory Allocation">
<link href="Complex-numbers.html" rel="prev" title="Complex numbers">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Precision"></span><div class="header">
<p>
Next: <a href="Memory-Allocation.html" accesskey="n" rel="next">Memory Allocation</a>, Previous: <a href="Complex-numbers.html" accesskey="p" rel="prev">Complex numbers</a>, Up: <a href="Data-Types-and-Files.html" accesskey="u" rel="up">Data Types and Files</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Precision-1"></span><h4 class="subsection">4.1.2 Precision</h4>
<span id="index-precision-3"></span>
<p>You can install single and long-double precision versions of FFTW,
which replace <code>double</code> with <code>float</code> and <code>long double</code>,
respectively (see <a href="Installation-and-Customization.html">Installation and Customization</a>). To use these
interfaces, you:
</p>
<ul>
<li> Link to the single/long-double libraries; on Unix, <code>-lfftw3f</code> or
<code>-lfftw3l</code> instead of (or in addition to) <code>-lfftw3</code>. (You
can link to the different-precision libraries simultaneously.)
</li><li> Include the <em>same</em> <code>&lt;fftw3.h&gt;</code> header file.
</li><li> Replace all lowercase instances of &lsquo;<samp>fftw_</samp>&rsquo; with &lsquo;<samp>fftwf_</samp>&rsquo; or
&lsquo;<samp>fftwl_</samp>&rsquo; for single or long-double precision, respectively.
(<code>fftw_complex</code> becomes <code>fftwf_complex</code>, <code>fftw_execute</code>
becomes <code>fftwf_execute</code>, etcetera.)
</li><li> Uppercase names, i.e. names beginning with &lsquo;<samp>FFTW_</samp>&rsquo;, remain the
same.
</li><li> Replace <code>double</code> with <code>float</code> or <code>long double</code> for
subroutine parameters.
</li></ul>
<p>Depending upon your compiler and/or hardware, <code>long double</code> may not
be any more precise than <code>double</code> (or may not be supported at all,
although it is standard in C99).
<span id="index-C99-2"></span>
</p>
<p>We also support using the nonstandard <code>__float128</code>
quadruple-precision type provided by recent versions of <code>gcc</code> on
32- and 64-bit x86 hardware (see <a href="Installation-and-Customization.html">Installation and Customization</a>).
To use this type, link with <code>-lfftw3q -lquadmath -lm</code> (the
<code>libquadmath</code> library provided by <code>gcc</code> is needed for
quadruple-precision trigonometric functions) and use &lsquo;<samp>fftwq_</samp>&rsquo;
identifiers.
</p>
</body>
</html>

239
fftw-3.3.10/doc/html/Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html Normal file
View File

@@ -0,0 +1,239 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Real even/odd DFTs (cosine/sine transforms) (FFTW 3.3.10)</title>
<meta name="description" content="Real even/odd DFTs (cosine/sine transforms) (FFTW 3.3.10)">
<meta name="keywords" content="Real even/odd DFTs (cosine/sine transforms) (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="More-DFTs-of-Real-Data.html" rel="up" title="More DFTs of Real Data">
<link href="The-Discrete-Hartley-Transform.html" rel="next" title="The Discrete Hartley Transform">
<link href="The-Halfcomplex_002dformat-DFT.html" rel="prev" title="The Halfcomplex-format DFT">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029"></span><div class="header">
<p>
Next: <a href="The-Discrete-Hartley-Transform.html" accesskey="n" rel="next">The Discrete Hartley Transform</a>, Previous: <a href="The-Halfcomplex_002dformat-DFT.html" accesskey="p" rel="prev">The Halfcomplex-format DFT</a>, Up: <a href="More-DFTs-of-Real-Data.html" accesskey="u" rel="up">More DFTs of Real Data</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029-1"></span><h4 class="subsection">2.5.2 Real even/odd DFTs (cosine/sine transforms)</h4>
<p>The Fourier transform of a real-even function <em>f(-x) = f(x)</em> is
real-even, and <em>i</em> times the Fourier transform of a real-odd
function <em>f(-x) = -f(x)</em> is real-odd. Similar results hold for a
discrete Fourier transform, and thus for these symmetries the need for
complex inputs/outputs is entirely eliminated. Moreover, one gains a
factor of two in speed/space from the fact that the data are real, and
an additional factor of two from the even/odd symmetry: only the
non-redundant (first) half of the array need be stored. The result is
the real-even DFT (<em>REDFT</em>) and the real-odd DFT (<em>RODFT</em>), also
known as the discrete cosine and sine transforms (<em>DCT</em> and
<em>DST</em>), respectively.
<span id="index-real_002deven-DFT"></span>
<span id="index-REDFT"></span>
<span id="index-real_002dodd-DFT"></span>
<span id="index-RODFT"></span>
<span id="index-discrete-cosine-transform"></span>
<span id="index-DCT"></span>
<span id="index-discrete-sine-transform"></span>
<span id="index-DST"></span>
</p>
<p>(In this section, we describe the 1d transforms; multi-dimensional
transforms are just a separable product of these transforms operating
along each dimension.)
</p>
<p>Because of the discrete sampling, one has an additional choice: is the
data even/odd around a sampling point, or around the point halfway
between two samples? The latter corresponds to <em>shifting</em> the
samples by <em>half</em> an interval, and gives rise to several transform
variants denoted by REDFT<em>ab</em> and RODFT<em>ab</em>: <em>a</em> and
<em>b</em> are <em>0</em> or <em>1</em>, and indicate whether the input
(<em>a</em>) and/or output (<em>b</em>) are shifted by half a sample
(<em>1</em> means it is shifted). These are also known as types I-IV of
the DCT and DST, and all four types are supported by FFTW&rsquo;s r2r
interface.<a id="DOCF3" href="#FOOT3"><sup>3</sup></a>
</p>
<p>The r2r kinds for the various REDFT and RODFT types supported by FFTW,
along with the boundary conditions at both ends of the <em>input</em>
array (<code>n</code> real numbers <code>in[j=0..n-1]</code>), are:
</p>
<ul>
<li> <code>FFTW_REDFT00</code> (DCT-I): even around <em>j=0</em> and even around <em>j=n-1</em>.
<span id="index-FFTW_005fREDFT00"></span>
</li><li> <code>FFTW_REDFT10</code> (DCT-II, &ldquo;the&rdquo; DCT): even around <em>j=-0.5</em> and even around <em>j=n-0.5</em>.
<span id="index-FFTW_005fREDFT10"></span>
</li><li> <code>FFTW_REDFT01</code> (DCT-III, &ldquo;the&rdquo; IDCT): even around <em>j=0</em> and odd around <em>j=n</em>.
<span id="index-FFTW_005fREDFT01"></span>
<span id="index-IDCT"></span>
</li><li> <code>FFTW_REDFT11</code> (DCT-IV): even around <em>j=-0.5</em> and odd around <em>j=n-0.5</em>.
<span id="index-FFTW_005fREDFT11"></span>
</li><li> <code>FFTW_RODFT00</code> (DST-I): odd around <em>j=-1</em> and odd around <em>j=n</em>.
<span id="index-FFTW_005fRODFT00"></span>
</li><li> <code>FFTW_RODFT10</code> (DST-II): odd around <em>j=-0.5</em> and odd around <em>j=n-0.5</em>.
<span id="index-FFTW_005fRODFT10"></span>
</li><li> <code>FFTW_RODFT01</code> (DST-III): odd around <em>j=-1</em> and even around <em>j=n-1</em>.
<span id="index-FFTW_005fRODFT01"></span>
</li><li> <code>FFTW_RODFT11</code> (DST-IV): odd around <em>j=-0.5</em> and even around <em>j=n-0.5</em>.
<span id="index-FFTW_005fRODFT11"></span>
</li></ul>
<p>Note that these symmetries apply to the &ldquo;logical&rdquo; array being
transformed; <strong>there are no constraints on your physical input
data</strong>. So, for example, if you specify a size-5 REDFT00 (DCT-I) of the
data <em>abcde</em>, it corresponds to the DFT of the logical even array
<em>abcdedcb</em> of size 8. A size-4 REDFT10 (DCT-II) of the data
<em>abcd</em> corresponds to the size-8 logical DFT of the even array
<em>abcddcba</em>, shifted by half a sample.
</p>
<p>All of these transforms are invertible. The inverse of R*DFT00 is
R*DFT00; of R*DFT10 is R*DFT01 and vice versa (these are often called
simply &ldquo;the&rdquo; DCT and IDCT, respectively); and of R*DFT11 is R*DFT11.
However, the transforms computed by FFTW are unnormalized, exactly
like the corresponding real and complex DFTs, so computing a transform
followed by its inverse yields the original array scaled by <em>N</em>,
where <em>N</em> is the <em>logical</em> DFT size. For REDFT00,
<em>N=2(n-1)</em>; for RODFT00, <em>N=2(n+1)</em>; otherwise, <em>N=2n</em>.
<span id="index-normalization-3"></span>
<span id="index-IDCT-1"></span>
</p>
<p>Note that the boundary conditions of the transform output array are
given by the input boundary conditions of the inverse transform.
Thus, the above transforms are all inequivalent in terms of
input/output boundary conditions, even neglecting the 0.5 shift
difference.
</p>
<p>FFTW is most efficient when <em>N</em> is a product of small factors; note
that this <em>differs</em> from the factorization of the physical size
<code>n</code> for REDFT00 and RODFT00! There is another oddity: <code>n=1</code>
REDFT00 transforms correspond to <em>N=0</em>, and so are <em>not
defined</em> (the planner will return <code>NULL</code>). Otherwise, any positive
<code>n</code> is supported.
</p>
<p>For the precise mathematical definitions of these transforms as used by
FFTW, see <a href="What-FFTW-Really-Computes.html">What FFTW Really Computes</a>. (For people accustomed to
the DCT/DST, FFTW&rsquo;s definitions have a coefficient of <em>2</em> in front
of the cos/sin functions so that they correspond precisely to an
even/odd DFT of size <em>N</em>. Some authors also include additional
multiplicative factors of
&radic;2
for selected inputs and outputs; this makes
the transform orthogonal, but sacrifices the direct equivalence to a
symmetric DFT.)
</p>
<span id="Which-type-do-you-need_003f"></span><h4 class="subsubheading">Which type do you need?</h4>
<p>Since the required flavor of even/odd DFT depends upon your problem,
you are the best judge of this choice, but we can make a few comments
on relative efficiency to help you in your selection. In particular,
R*DFT01 and R*DFT10 tend to be slightly faster than R*DFT11
(especially for odd sizes), while the R*DFT00 transforms are sometimes
significantly slower (especially for even sizes).<a id="DOCF4" href="#FOOT4"><sup>4</sup></a>
</p>
<p>Thus, if only the boundary conditions on the transform inputs are
specified, we generally recommend R*DFT10 over R*DFT00 and R*DFT01 over
R*DFT11 (unless the half-sample shift or the self-inverse property is
significant for your problem).
</p>
<p>If performance is important to you and you are using only small sizes
(say <em>n&lt;200</em>), e.g. for multi-dimensional transforms, then you
might consider generating hard-coded transforms of those sizes and types
that you are interested in (see <a href="Generating-your-own-code.html">Generating your own code</a>).
</p>
<p>We are interested in hearing what types of symmetric transforms you find
most useful.
</p>
<div class="footnote">
<hr>
<h4 class="footnotes-heading">Footnotes</h4>
<h5><a id="FOOT3" href="#DOCF3">(3)</a></h3>
<p>There are also type V-VIII transforms, which
correspond to a logical DFT of <em>odd</em> size <em>N</em>, independent of
whether the physical size <code>n</code> is odd, but we do not support these
variants.</p>
<h5><a id="FOOT4" href="#DOCF4">(4)</a></h3>
<p>R*DFT00 is
sometimes slower in FFTW because we discovered that the standard
algorithm for computing this by a pre/post-processed real DFT&mdash;the
algorithm used in FFTPACK, Numerical Recipes, and other sources for
decades now&mdash;has serious numerical problems: it already loses several
decimal places of accuracy for 16k sizes. There seem to be only two
alternatives in the literature that do not suffer similarly: a
recursive decomposition into smaller DCTs, which would require a large
set of codelets for efficiency and generality, or sacrificing a factor of
2
in speed to use a real DFT of twice the size. We currently
employ the latter technique for general <em>n</em>, as well as a limited
form of the former method: a split-radix decomposition when <em>n</em>
is odd (<em>N</em> a multiple of 4). For <em>N</em> containing many
factors of 2, the split-radix method seems to recover most of the
speed of the standard algorithm without the accuracy tradeoff.</p>
</div>
<hr>
<div class="header">
<p>
Next: <a href="The-Discrete-Hartley-Transform.html" accesskey="n" rel="next">The Discrete Hartley Transform</a>, Previous: <a href="The-Halfcomplex_002dformat-DFT.html" accesskey="p" rel="prev">The Halfcomplex-format DFT</a>, Up: <a href="More-DFTs-of-Real-Data.html" accesskey="u" rel="up">More DFTs of Real Data</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

123
fftw-3.3.10/doc/html/Real_002ddata-DFT-Array-Format.html Normal file
View File

@@ -0,0 +1,123 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Real-data DFT Array Format (FFTW 3.3.10)</title>
<meta name="description" content="Real-data DFT Array Format (FFTW 3.3.10)">
<meta name="keywords" content="Real-data DFT Array Format (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Basic-Interface.html" rel="up" title="Basic Interface">
<link href="Real_002dto_002dReal-Transforms.html" rel="next" title="Real-to-Real Transforms">
<link href="Real_002ddata-DFTs.html" rel="prev" title="Real-data DFTs">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Real_002ddata-DFT-Array-Format"></span><div class="header">
<p>
Next: <a href="Real_002dto_002dReal-Transforms.html" accesskey="n" rel="next">Real-to-Real Transforms</a>, Previous: <a href="Real_002ddata-DFTs.html" accesskey="p" rel="prev">Real-data DFTs</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Real_002ddata-DFT-Array-Format-1"></span><h4 class="subsection">4.3.4 Real-data DFT Array Format</h4>
<span id="index-r2c_002fc2r-multi_002ddimensional-array-format-1"></span>
<p>The output of a DFT of real data (r2c) contains symmetries that, in
principle, make half of the outputs redundant (see <a href="What-FFTW-Really-Computes.html">What FFTW Really Computes</a>). (Similarly for the input of an inverse c2r transform.) In
practice, it is not possible to entirely realize these savings in an
efficient and understandable format that generalizes to
multi-dimensional transforms. Instead, the output of the r2c
transforms is <em>slightly</em> over half of the output of the
corresponding complex transform. We do not &ldquo;pack&rdquo; the data in any
way, but store it as an ordinary array of <code>fftw_complex</code> values.
In fact, this data is simply a subsection of what would be the array in
the corresponding complex transform.
</p>
<p>Specifically, for a real transform of <em>d</em> (= <code>rank</code>)
dimensions n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
, the complex data is an n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;(n<sub>d-1</sub>/2 + 1)
array of
<code>fftw_complex</code> values in row-major order (with the division rounded
down). That is, we only store the <em>lower</em> half (non-negative
frequencies), plus one element, of the last dimension of the data from
the ordinary complex transform. (We could have instead taken half of
any other dimension, but implementation turns out to be simpler if the
last, contiguous, dimension is used.)
</p>
<span id="index-out_002dof_002dplace-1"></span>
<p>For an out-of-place transform, the real data is simply an array with
physical dimensions n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
in row-major order.
</p>
<span id="index-in_002dplace-4"></span>
<span id="index-padding-3"></span>
<p>For an in-place transform, some complications arise since the complex data
is slightly larger than the real data. In this case, the final
dimension of the real data must be <em>padded</em> with extra values to
accommodate the size of the complex data&mdash;two extra if the last
dimension is even and one if it is odd. That is, the last dimension of
the real data must physically contain
2 * (n<sub>d-1</sub>/2+1)
<code>double</code> values (exactly enough to hold the complex data). This
physical array size does not, however, change the <em>logical</em> array
size&mdash;only
n<sub>d-1</sub>
values are actually stored in the last dimension, and
n<sub>d-1</sub>
is the last dimension passed to the planner.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Real_002dto_002dReal-Transforms.html" accesskey="n" rel="next">Real-to-Real Transforms</a>, Previous: <a href="Real_002ddata-DFTs.html" accesskey="p" rel="prev">Real-data DFTs</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

191
fftw-3.3.10/doc/html/Real_002ddata-DFTs.html Normal file
View File

@@ -0,0 +1,191 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Real-data DFTs (FFTW 3.3.10)</title>
<meta name="description" content="Real-data DFTs (FFTW 3.3.10)">
<meta name="keywords" content="Real-data DFTs (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Basic-Interface.html" rel="up" title="Basic Interface">
<link href="Real_002ddata-DFT-Array-Format.html" rel="next" title="Real-data DFT Array Format">
<link href="Planner-Flags.html" rel="prev" title="Planner Flags">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Real_002ddata-DFTs"></span><div class="header">
<p>
Next: <a href="Real_002ddata-DFT-Array-Format.html" accesskey="n" rel="next">Real-data DFT Array Format</a>, Previous: <a href="Planner-Flags.html" accesskey="p" rel="prev">Planner Flags</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Real_002ddata-DFTs-1"></span><h4 class="subsection">4.3.3 Real-data DFTs</h4>
<div class="example">
<pre class="example">fftw_plan fftw_plan_dft_r2c_1d(int n0,
double *in, fftw_complex *out,
unsigned flags);
fftw_plan fftw_plan_dft_r2c_2d(int n0, int n1,
double *in, fftw_complex *out,
unsigned flags);
fftw_plan fftw_plan_dft_r2c_3d(int n0, int n1, int n2,
double *in, fftw_complex *out,
unsigned flags);
fftw_plan fftw_plan_dft_r2c(int rank, const int *n,
double *in, fftw_complex *out,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft_005fr2c_005f1d-1"></span>
<span id="index-fftw_005fplan_005fdft_005fr2c_005f2d-1"></span>
<span id="index-fftw_005fplan_005fdft_005fr2c_005f3d-1"></span>
<span id="index-fftw_005fplan_005fdft_005fr2c-1"></span>
<span id="index-r2c-2"></span>
<p>Plan a real-input/complex-output discrete Fourier transform (DFT) in
zero or more dimensions, returning an <code>fftw_plan</code> (see <a href="Using-Plans.html">Using Plans</a>).
</p>
<p>Once you have created a plan for a certain transform type and
parameters, then creating another plan of the same type and parameters,
but for different arrays, is fast and shares constant data with the
first plan (if it still exists).
</p>
<p>The planner returns <code>NULL</code> if the plan cannot be created. A
non-<code>NULL</code> plan is always returned by the basic interface unless
you are using a customized FFTW configuration supporting a restricted
set of transforms, or if you use the <code>FFTW_PRESERVE_INPUT</code> flag
with a multi-dimensional out-of-place c2r transform (see below).
</p>
<span id="Arguments-1"></span><h4 class="subsubheading">Arguments</h4>
<ul>
<li> <code>rank</code> is the rank of the transform (it should be the size of the
array <code>*n</code>), and can be any non-negative integer. (See <a href="Complex-Multi_002dDimensional-DFTs.html">Complex Multi-Dimensional DFTs</a>, for the definition of &ldquo;rank&rdquo;.) The
&lsquo;<samp>_1d</samp>&rsquo;, &lsquo;<samp>_2d</samp>&rsquo;, and &lsquo;<samp>_3d</samp>&rsquo; planners correspond to a
<code>rank</code> of <code>1</code>, <code>2</code>, and <code>3</code>, respectively. The rank
may be zero, which is equivalent to a rank-1 transform of size 1, i.e. a
copy of one real number (with zero imaginary part) from input to output.
</li><li> <code>n0</code>, <code>n1</code>, <code>n2</code>, or <code>n[0..rank-1]</code>, (as appropriate
for each routine) specify the size of the transform dimensions. They
can be any positive integer. This is different in general from the
<em>physical</em> array dimensions, which are described in <a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a>.
<ul class="no-bullet">
<li>- FFTW is best at handling sizes of the form
2<sup>a</sup> 3<sup>b</sup> 5<sup>c</sup> 7<sup>d</sup>
11<sup>e</sup> 13<sup>f</sup>,
where <em>e+f</em> is either <em>0</em> or <em>1</em>, and the other exponents
are arbitrary. Other sizes are computed by means of a slow,
general-purpose algorithm (which nevertheless retains <i>O</i>(<i>n</i>&nbsp;log&nbsp;<i>n</i>)
performance even for prime sizes). (It is possible to customize FFTW
for different array sizes; see <a href="Installation-and-Customization.html">Installation and Customization</a>.)
Transforms whose sizes are powers of <em>2</em> are especially fast, and
it is generally beneficial for the <em>last</em> dimension of an r2c/c2r
transform to be <em>even</em>.
</li></ul>
</li><li> <code>in</code> and <code>out</code> point to the input and output arrays of the
transform, which may be the same (yielding an in-place transform).
<span id="index-in_002dplace-3"></span>
These arrays are overwritten during planning, unless
<code>FFTW_ESTIMATE</code> is 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 <a href="Real_002ddata-DFT-Array-Format.html">Real-data DFT Array Format</a>.
<span id="index-padding-2"></span>
</li><li> <span id="index-flags-3"></span>
<code>flags</code> is a bitwise OR (&lsquo;<samp>|</samp>&rsquo;) of zero or more planner flags,
as defined in <a href="Planner-Flags.html">Planner Flags</a>.
</li></ul>
<p>The inverse transforms, taking complex input (storing the non-redundant
half of a logically Hermitian array) to real output, are given by:
</p>
<div class="example">
<pre class="example">fftw_plan fftw_plan_dft_c2r_1d(int n0,
fftw_complex *in, double *out,
unsigned flags);
fftw_plan fftw_plan_dft_c2r_2d(int n0, int n1,
fftw_complex *in, double *out,
unsigned flags);
fftw_plan fftw_plan_dft_c2r_3d(int n0, int n1, int n2,
fftw_complex *in, double *out,
unsigned flags);
fftw_plan fftw_plan_dft_c2r(int rank, const int *n,
fftw_complex *in, double *out,
unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fdft_005fc2r_005f1d-1"></span>
<span id="index-fftw_005fplan_005fdft_005fc2r_005f2d"></span>
<span id="index-fftw_005fplan_005fdft_005fc2r_005f3d"></span>
<span id="index-fftw_005fplan_005fdft_005fc2r"></span>
<span id="index-c2r-2"></span>
<p>The arguments are the same as for the r2c transforms, except that the
input and output data formats are reversed.
</p>
<p>FFTW computes an unnormalized transform: computing an r2c followed by a
c2r transform (or vice versa) will result in the original data
multiplied by the size of the transform (the product of the logical
dimensions).
<span id="index-normalization-6"></span>
An r2c transform produces the same output as a <code>FFTW_FORWARD</code>
complex DFT of the same input, and a c2r transform is correspondingly
equivalent to <code>FFTW_BACKWARD</code>. For more information, see <a href="What-FFTW-Really-Computes.html">What FFTW Really Computes</a>.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Real_002ddata-DFT-Array-Format.html" accesskey="n" rel="next">Real-data DFT Array Format</a>, Previous: <a href="Planner-Flags.html" accesskey="p" rel="prev">Planner Flags</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

152
fftw-3.3.10/doc/html/Real_002dto_002dReal-Transform-Kinds.html Normal file
View File

@@ -0,0 +1,152 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Real-to-Real Transform Kinds (FFTW 3.3.10)</title>
<meta name="description" content="Real-to-Real Transform Kinds (FFTW 3.3.10)">
<meta name="keywords" content="Real-to-Real Transform Kinds (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Basic-Interface.html" rel="up" title="Basic Interface">
<link href="Advanced-Interface.html" rel="next" title="Advanced Interface">
<link href="Real_002dto_002dReal-Transforms.html" rel="prev" title="Real-to-Real Transforms">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Real_002dto_002dReal-Transform-Kinds"></span><div class="header">
<p>
Previous: <a href="Real_002dto_002dReal-Transforms.html" accesskey="p" rel="prev">Real-to-Real Transforms</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Real_002dto_002dReal-Transform-Kinds-1"></span><h4 class="subsection">4.3.6 Real-to-Real Transform Kinds</h4>
<span id="index-kind-_0028r2r_0029-1"></span>
<p>FFTW currently supports 11 different r2r transform kinds, specified by
one of the constants below. For the precise definitions of these
transforms, see <a href="What-FFTW-Really-Computes.html">What FFTW Really Computes</a>. For a more colloquial
introduction to these transform kinds, see <a href="More-DFTs-of-Real-Data.html">More DFTs of Real Data</a>.
</p>
<p>For dimension of size <code>n</code>, there is a corresponding &ldquo;logical&rdquo;
dimension <code>N</code> that determines the normalization (and the optimal
factorization); the formula for <code>N</code> is given for each kind below.
Also, with each transform kind is listed its corrsponding inverse
transform. FFTW computes unnormalized transforms: a transform followed
by its inverse will result in the original data multiplied by <code>N</code>
(or the product of the <code>N</code>&rsquo;s for each dimension, in
multi-dimensions).
<span id="index-normalization-7"></span>
</p>
<ul>
<li> <span id="index-FFTW_005fR2HC-1"></span>
<code>FFTW_R2HC</code> computes a real-input DFT with output in
&ldquo;halfcomplex&rdquo; format, i.e. real and imaginary parts for a transform of
size <code>n</code> stored as:
<p align=center>
r<sub>0</sub>, r<sub>1</sub>, r<sub>2</sub>, ..., r<sub>n/2</sub>, i<sub>(n+1)/2-1</sub>, ..., i<sub>2</sub>, i<sub>1</sub>
</p>
(Logical <code>N=n</code>, inverse is <code>FFTW_HC2R</code>.)
</li><li> <span id="index-FFTW_005fHC2R-1"></span>
<code>FFTW_HC2R</code> computes the reverse of <code>FFTW_R2HC</code>, above.
(Logical <code>N=n</code>, inverse is <code>FFTW_R2HC</code>.)
</li><li> <span id="index-FFTW_005fDHT-1"></span>
<code>FFTW_DHT</code> computes a discrete Hartley transform.
(Logical <code>N=n</code>, inverse is <code>FFTW_DHT</code>.)
<span id="index-discrete-Hartley-transform-1"></span>
</li><li> <span id="index-FFTW_005fREDFT00-2"></span>
<code>FFTW_REDFT00</code> computes an REDFT00 transform, i.e. a DCT-I.
(Logical <code>N=2*(n-1)</code>, inverse is <code>FFTW_REDFT00</code>.)
<span id="index-discrete-cosine-transform-1"></span>
<span id="index-DCT-1"></span>
</li><li> <span id="index-FFTW_005fREDFT10-1"></span>
<code>FFTW_REDFT10</code> computes an REDFT10 transform, i.e. a DCT-II (sometimes called &ldquo;the&rdquo; DCT).
(Logical <code>N=2*n</code>, inverse is <code>FFTW_REDFT01</code>.)
</li><li> <span id="index-FFTW_005fREDFT01-1"></span>
<code>FFTW_REDFT01</code> computes an REDFT01 transform, i.e. a DCT-III (sometimes called &ldquo;the&rdquo; IDCT, being the inverse of DCT-II).
(Logical <code>N=2*n</code>, inverse is <code>FFTW_REDFT=10</code>.)
<span id="index-IDCT-2"></span>
</li><li> <span id="index-FFTW_005fREDFT11-1"></span>
<code>FFTW_REDFT11</code> computes an REDFT11 transform, i.e. a DCT-IV.
(Logical <code>N=2*n</code>, inverse is <code>FFTW_REDFT11</code>.)
</li><li> <span id="index-FFTW_005fRODFT00-1"></span>
<code>FFTW_RODFT00</code> computes an RODFT00 transform, i.e. a DST-I.
(Logical <code>N=2*(n+1)</code>, inverse is <code>FFTW_RODFT00</code>.)
<span id="index-discrete-sine-transform-1"></span>
<span id="index-DST-1"></span>
</li><li> <span id="index-FFTW_005fRODFT10-1"></span>
<code>FFTW_RODFT10</code> computes an RODFT10 transform, i.e. a DST-II.
(Logical <code>N=2*n</code>, inverse is <code>FFTW_RODFT01</code>.)
</li><li> <span id="index-FFTW_005fRODFT01-1"></span>
<code>FFTW_RODFT01</code> computes an RODFT01 transform, i.e. a DST-III.
(Logical <code>N=2*n</code>, inverse is <code>FFTW_RODFT=10</code>.)
</li><li> <span id="index-FFTW_005fRODFT11-1"></span>
<code>FFTW_RODFT11</code> computes an RODFT11 transform, i.e. a DST-IV.
(Logical <code>N=2*n</code>, inverse is <code>FFTW_RODFT11</code>.)
</li></ul>
<hr>
<div class="header">
<p>
Previous: <a href="Real_002dto_002dReal-Transforms.html" accesskey="p" rel="prev">Real-to-Real Transforms</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

168
fftw-3.3.10/doc/html/Real_002dto_002dReal-Transforms.html Normal file
View File

@@ -0,0 +1,168 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Real-to-Real Transforms (FFTW 3.3.10)</title>
<meta name="description" content="Real-to-Real Transforms (FFTW 3.3.10)">
<meta name="keywords" content="Real-to-Real Transforms (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Basic-Interface.html" rel="up" title="Basic Interface">
<link href="Real_002dto_002dReal-Transform-Kinds.html" rel="next" title="Real-to-Real Transform Kinds">
<link href="Real_002ddata-DFT-Array-Format.html" rel="prev" title="Real-data DFT Array Format">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Real_002dto_002dReal-Transforms"></span><div class="header">
<p>
Next: <a href="Real_002dto_002dReal-Transform-Kinds.html" accesskey="n" rel="next">Real-to-Real Transform Kinds</a>, Previous: <a href="Real_002ddata-DFT-Array-Format.html" accesskey="p" rel="prev">Real-data DFT Array Format</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Real_002dto_002dReal-Transforms-1"></span><h4 class="subsection">4.3.5 Real-to-Real Transforms</h4>
<span id="index-r2r-1"></span>
<div class="example">
<pre class="example">fftw_plan fftw_plan_r2r_1d(int n, double *in, double *out,
fftw_r2r_kind kind, unsigned flags);
fftw_plan fftw_plan_r2r_2d(int n0, int n1, double *in, double *out,
fftw_r2r_kind kind0, fftw_r2r_kind kind1,
unsigned flags);
fftw_plan fftw_plan_r2r_3d(int n0, int n1, int n2,
double *in, double *out,
fftw_r2r_kind kind0,
fftw_r2r_kind kind1,
fftw_r2r_kind kind2,
unsigned flags);
fftw_plan fftw_plan_r2r(int rank, const int *n, double *in, double *out,
const fftw_r2r_kind *kind, unsigned flags);
</pre></div>
<span id="index-fftw_005fplan_005fr2r_005f1d-1"></span>
<span id="index-fftw_005fplan_005fr2r_005f2d-1"></span>
<span id="index-fftw_005fplan_005fr2r_005f3d-1"></span>
<span id="index-fftw_005fplan_005fr2r-1"></span>
<p>Plan a real input/output (r2r) transform of various kinds in zero or
more dimensions, returning an <code>fftw_plan</code> (see <a href="Using-Plans.html">Using Plans</a>).
</p>
<p>Once you have created a plan for a certain transform type and
parameters, then creating another plan of the same type and parameters,
but for different arrays, is fast and shares constant data with the
first plan (if it still exists).
</p>
<p>The planner returns <code>NULL</code> if the plan cannot be created. A
non-<code>NULL</code> plan is always returned by the basic interface unless
you are using a customized FFTW configuration supporting a restricted
set of transforms, or for size-1 <code>FFTW_REDFT00</code> kinds (which are
not defined).
<span id="index-FFTW_005fREDFT00-1"></span>
</p>
<span id="Arguments-2"></span><h4 class="subsubheading">Arguments</h4>
<ul>
<li> <code>rank</code> is the dimensionality of the transform (it should be the
size of the arrays <code>*n</code> and <code>*kind</code>), and can be any
non-negative integer. The &lsquo;<samp>_1d</samp>&rsquo;, &lsquo;<samp>_2d</samp>&rsquo;, and &lsquo;<samp>_3d</samp>&rsquo;
planners correspond to a <code>rank</code> of <code>1</code>, <code>2</code>, and
<code>3</code>, respectively. A <code>rank</code> of zero is equivalent to a copy
of one number from input to output.
</li><li> <code>n</code>, or <code>n0</code>/<code>n1</code>/<code>n2</code>, or <code>n[rank]</code>,
respectively, gives the (physical) size of the transform dimensions.
They can be any positive integer.
<ul class="no-bullet">
<li>- <span id="index-row_002dmajor-2"></span>
Multi-dimensional arrays are stored in row-major order with dimensions:
<code>n0</code> x <code>n1</code>; or <code>n0</code> x <code>n1</code> x <code>n2</code>; or
<code>n[0]</code> x <code>n[1]</code> x ... x <code>n[rank-1]</code>.
See <a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>.
</li><li>- FFTW is generally best at handling sizes of the form
2<sup>a</sup> 3<sup>b</sup> 5<sup>c</sup> 7<sup>d</sup>
11<sup>e</sup> 13<sup>f</sup>,
where <em>e+f</em> is either <em>0</em> or <em>1</em>, and the other exponents
are arbitrary. Other sizes are computed by means of a slow,
general-purpose algorithm (which nevertheless retains <i>O</i>(<i>n</i>&nbsp;log&nbsp;<i>n</i>)
performance even for prime sizes). (It is possible to customize FFTW
for different array sizes; see <a href="Installation-and-Customization.html">Installation and Customization</a>.)
Transforms whose sizes are powers of <em>2</em> are especially fast.
</li><li>- For a <code>REDFT00</code> or <code>RODFT00</code> transform kind in a dimension of
size <em>n</em>, it is <em>n-1</em> or <em>n+1</em>, respectively, that
should be factorizable in the above form.
</li></ul>
</li><li> <code>in</code> and <code>out</code> point to the input and output arrays of the
transform, which may be the same (yielding an in-place transform).
<span id="index-in_002dplace-5"></span>
These arrays are overwritten during planning, unless
<code>FFTW_ESTIMATE</code> is used in the flags. (The arrays need not be
initialized, but they must be allocated.)
</li><li> <code>kind</code>, or <code>kind0</code>/<code>kind1</code>/<code>kind2</code>, or
<code>kind[rank]</code>, is the kind of r2r transform used for the
corresponding dimension. The valid kind constants are described in
<a href="Real_002dto_002dReal-Transform-Kinds.html">Real-to-Real Transform Kinds</a>. 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.
</li><li> <span id="index-flags-4"></span>
<code>flags</code> is a bitwise OR (&lsquo;<samp>|</samp>&rsquo;) of zero or more planner flags,
as defined in <a href="Planner-Flags.html">Planner Flags</a>.
</li></ul>
<hr>
<div class="header">
<p>
Next: <a href="Real_002dto_002dReal-Transform-Kinds.html" accesskey="n" rel="next">Real-to-Real Transform Kinds</a>, Previous: <a href="Real_002ddata-DFT-Array-Format.html" accesskey="p" rel="prev">Real-data DFT Array Format</a>, Up: <a href="Basic-Interface.html" accesskey="u" rel="up">Basic Interface</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

173
fftw-3.3.10/doc/html/Reversing-array-dimensions.html Normal file
View File

@@ -0,0 +1,173 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Reversing array dimensions (FFTW 3.3.10)</title>
<meta name="description" content="Reversing array dimensions (FFTW 3.3.10)">
<meta name="keywords" content="Reversing array dimensions (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Calling-FFTW-from-Modern-Fortran.html" rel="up" title="Calling FFTW from Modern Fortran">
<link href="FFTW-Fortran-type-reference.html" rel="next" title="FFTW Fortran type reference">
<link href="Extended-and-quadruple-precision-in-Fortran.html" rel="prev" title="Extended and quadruple precision in Fortran">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Reversing-array-dimensions"></span><div class="header">
<p>
Next: <a href="FFTW-Fortran-type-reference.html" accesskey="n" rel="next">FFTW Fortran type reference</a>, Previous: <a href="Overview-of-Fortran-interface.html" accesskey="p" rel="prev">Overview of Fortran interface</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Reversing-array-dimensions-1"></span><h3 class="section">7.2 Reversing array dimensions</h3>
<span id="index-row_002dmajor-6"></span>
<span id="index-column_002dmajor-1"></span>
<p>A minor annoyance in calling FFTW from Fortran is that FFTW&rsquo;s array
dimensions are defined in the C convention (row-major order), while
Fortran&rsquo;s array dimensions are the opposite convention (column-major
order). See <a href="Multi_002ddimensional-Array-Format.html">Multi-dimensional Array Format</a>. This is just a
bookkeeping difference, with no effect on performance. The only
consequence of this is that, whenever you create an FFTW plan for a
multi-dimensional transform, you must always <em>reverse the
ordering of the dimensions</em>.
</p>
<p>For example, consider the three-dimensional (L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
) arrays:
</p>
<div class="example">
<pre class="example"> complex(C_DOUBLE_COMPLEX), dimension(L,M,N) :: in, out
</pre></div>
<p>To plan a DFT for these arrays using <code>fftw_plan_dft_3d</code>, you could do:
</p>
<span id="index-fftw_005fplan_005fdft_005f3d-2"></span>
<div class="example">
<pre class="example"> plan = fftw_plan_dft_3d(N,M,L, in,out, FFTW_FORWARD,FFTW_ESTIMATE)
</pre></div>
<p>That is, from FFTW&rsquo;s perspective this is a N&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;L
array.
<em>No data transposition need occur</em>, as this is <em>only
notation</em>. Similarly, to use the more generic routine
<code>fftw_plan_dft</code> with the same arrays, you could do:
</p>
<div class="example">
<pre class="example"> integer(C_INT), dimension(3) :: n = [N,M,L]
plan = fftw_plan_dft_3d(3, n, in,out, FFTW_FORWARD,FFTW_ESTIMATE)
</pre></div>
<p>Note, by the way, that this is different from the legacy Fortran
interface (see <a href="Fortran_002dinterface-routines.html">Fortran-interface routines</a>), which automatically
reverses the order of the array dimension for you. Here, you are
calling the C interface directly, so there is no &ldquo;translation&rdquo; layer.
</p>
<span id="index-r2c_002fc2r-multi_002ddimensional-array-format-2"></span>
<p>An important thing to keep in mind is the implication of this for
multidimensional real-to-complex transforms (see <a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a>). In C, a multidimensional real-to-complex DFT
chops the last dimension roughly in half (N&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;L
real input
goes to N&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;L/2+1
complex output). In Fortran, because
the array dimension notation is reversed, the <em>first</em> dimension of
the complex data is chopped roughly in half. For example consider the
&lsquo;<samp>r2c</samp>&rsquo; transform of L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
real input in Fortran:
</p>
<span id="index-fftw_005fplan_005fdft_005fr2c_005f3d-2"></span>
<span id="index-fftw_005fexecute_005fdft_005fr2c-1"></span>
<div class="example">
<pre class="example"> type(C_PTR) :: plan
real(C_DOUBLE), dimension(L,M,N) :: in
complex(C_DOUBLE_COMPLEX), dimension(L/2+1,M,N) :: out
plan = fftw_plan_dft_r2c_3d(N,M,L, in,out, FFTW_ESTIMATE)
...
call fftw_execute_dft_r2c(plan, in, out)
</pre></div>
<span id="index-in_002dplace-9"></span>
<span id="index-padding-5"></span>
<p>Alternatively, for an in-place r2c transform, as described in the C
documentation we must <em>pad</em> the <em>first</em> dimension of the
real input with an extra two entries (which are ignored by FFTW) so as
to leave enough space for the complex output. The input is
<em>allocated</em> as a 2[L/2+1]&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
array, even though only
L&nbsp;&times;&nbsp;M&nbsp;&times;&nbsp;N
of it is actually used. In this example, we will
allocate the array as a pointer type, using &lsquo;<samp>fftw_alloc</samp>&rsquo; to
ensure aligned memory for maximum performance (see <a href="Allocating-aligned-memory-in-Fortran.html">Allocating aligned memory in Fortran</a>); this also makes it easy to reference the
same memory as both a real array and a complex array.
</p>
<span id="index-fftw_005falloc_005fcomplex-4"></span>
<span id="index-c_005ff_005fpointer"></span>
<div class="example">
<pre class="example"> real(C_DOUBLE), pointer :: in(:,:,:)
complex(C_DOUBLE_COMPLEX), pointer :: out(:,:,:)
type(C_PTR) :: plan, data
data = fftw_alloc_complex(int((L/2+1) * M * N, C_SIZE_T))
call c_f_pointer(data, in, [2*(L/2+1),M,N])
call c_f_pointer(data, out, [L/2+1,M,N])
plan = fftw_plan_dft_r2c_3d(N,M,L, in,out, FFTW_ESTIMATE)
...
call fftw_execute_dft_r2c(plan, in, out)
...
call fftw_destroy_plan(plan)
call fftw_free(data)
</pre></div>
<hr>
<div class="header">
<p>
Next: <a href="FFTW-Fortran-type-reference.html" accesskey="n" rel="next">FFTW Fortran type reference</a>, Previous: <a href="Overview-of-Fortran-interface.html" accesskey="p" rel="prev">Overview of Fortran interface</a>, Up: <a href="Calling-FFTW-from-Modern-Fortran.html" accesskey="u" rel="up">Calling FFTW from Modern Fortran</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

107
fftw-3.3.10/doc/html/Row_002dmajor-Format.html Normal file
View File

@@ -0,0 +1,107 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Row-major Format (FFTW 3.3.10)</title>
<meta name="description" content="Row-major Format (FFTW 3.3.10)">
<meta name="keywords" content="Row-major Format (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Multi_002ddimensional-Array-Format.html" rel="up" title="Multi-dimensional Array Format">
<link href="Column_002dmajor-Format.html" rel="next" title="Column-major Format">
<link href="Multi_002ddimensional-Array-Format.html" rel="prev" title="Multi-dimensional Array Format">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="Row_002dmajor-Format"></span><div class="header">
<p>
Next: <a href="Column_002dmajor-Format.html" accesskey="n" rel="next">Column-major Format</a>, Previous: <a href="Multi_002ddimensional-Array-Format.html" accesskey="p" rel="prev">Multi-dimensional Array Format</a>, Up: <a href="Multi_002ddimensional-Array-Format.html" accesskey="u" rel="up">Multi-dimensional Array Format</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="Row_002dmajor-Format-1"></span><h4 class="subsection">3.2.1 Row-major Format</h4>
<span id="index-row_002dmajor"></span>
<p>The multi-dimensional arrays passed to <code>fftw_plan_dft</code> etcetera
are expected to be stored as a single contiguous block in
<em>row-major</em> order (sometimes called &ldquo;C order&rdquo;). Basically, this
means that as you step through adjacent memory locations, the first
dimension&rsquo;s index varies most slowly and the last dimension&rsquo;s index
varies most quickly.
</p>
<p>To be more explicit, let us consider an array of rank <em>d</em> whose
dimensions are n<sub>0</sub>&nbsp;&times;&nbsp;n<sub>1</sub>&nbsp;&times;&nbsp;n<sub>2</sub>&nbsp;&times;&nbsp;&hellip;&nbsp;&times;&nbsp;n<sub>d-1</sub>
. Now, we specify a location in the array by a
sequence of <em>d</em> (zero-based) indices, one for each dimension:
(i<sub>0</sub>, i<sub>1</sub>, i<sub>2</sub>,..., i<sub>d-1</sub>).
If the array is stored in row-major
order, then this element is located at the position
i<sub>d-1</sub> + n<sub>d-1</sub> * (i<sub>d-2</sub> + n<sub>d-2</sub> * (... + n<sub>1</sub> * i<sub>0</sub>)).
</p>
<p>Note that, for the ordinary complex DFT, each element of the array
must be of type <code>fftw_complex</code>; i.e. a (real, imaginary) pair of
(double-precision) numbers.
</p>
<p>In the advanced FFTW interface, the physical dimensions <em>n</em> from
which the indices are computed can be different from (larger than)
the logical dimensions of the transform to be computed, in order to
transform a subset of a larger array.
<span id="index-advanced-interface-2"></span>
Note also that, in the advanced interface, the expression above is
multiplied by a <em>stride</em> to get the actual array index&mdash;this is
useful in situations where each element of the multi-dimensional array
is actually a data structure (or another array), and you just want to
transform a single field. In the basic interface, however, the stride
is 1.
<span id="index-stride"></span>
</p>
</body>
</html>

132
fftw-3.3.10/doc/html/SIMD-alignment-and-fftw_005fmalloc.html Normal file
View File

@@ -0,0 +1,132 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>SIMD alignment and fftw_malloc (FFTW 3.3.10)</title>
<meta name="description" content="SIMD alignment and fftw_malloc (FFTW 3.3.10)">
<meta name="keywords" content="SIMD alignment and fftw_malloc (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="Other-Important-Topics.html" rel="up" title="Other Important Topics">
<link href="Multi_002ddimensional-Array-Format.html" rel="next" title="Multi-dimensional Array Format">
<link href="Other-Important-Topics.html" rel="prev" title="Other Important Topics">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="SIMD-alignment-and-fftw_005fmalloc"></span><div class="header">
<p>
Next: <a href="Multi_002ddimensional-Array-Format.html" accesskey="n" rel="next">Multi-dimensional Array Format</a>, Previous: <a href="Other-Important-Topics.html" accesskey="p" rel="prev">Other Important Topics</a>, Up: <a href="Other-Important-Topics.html" accesskey="u" rel="up">Other Important Topics</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="SIMD-alignment-and-fftw_005fmalloc-1"></span><h3 class="section">3.1 SIMD alignment and fftw_malloc</h3>
<p>SIMD, which stands for &ldquo;Single Instruction Multiple Data,&rdquo; is a set of
special operations supported by some processors to perform a single
operation on several numbers (usually 2 or 4) simultaneously. SIMD
floating-point instructions are available on several popular CPUs:
SSE/SSE2/AVX/AVX2/AVX512/KCVI on some x86/x86-64 processors, AltiVec and
VSX on some POWER/PowerPCs, NEON on some ARM models. FFTW can be
compiled to support the SIMD instructions on any of these systems.
<span id="index-SIMD-1"></span>
<span id="index-SSE"></span>
<span id="index-SSE2"></span>
<span id="index-AVX"></span>
<span id="index-AVX2"></span>
<span id="index-AVX512"></span>
<span id="index-AltiVec"></span>
<span id="index-VSX"></span>
<span id="index-precision-2"></span>
</p>
<p>A program linking to an FFTW library compiled with SIMD support can
obtain a nonnegligible speedup for most complex and r2c/c2r
transforms. In order to obtain this speedup, however, the arrays of
complex (or real) data passed to FFTW must be specially aligned in
memory (typically 16-byte aligned), and often this alignment is more
stringent than that provided by the usual <code>malloc</code> (etc.)
allocation routines.
</p>
<span id="index-portability"></span>
<p>In order to guarantee proper alignment for SIMD, therefore, in case
your program is ever linked against a SIMD-using FFTW, we recommend
allocating your transform data with <code>fftw_malloc</code> and
de-allocating it with <code>fftw_free</code>.
<span id="index-fftw_005fmalloc-1"></span>
<span id="index-fftw_005ffree-1"></span>
These have exactly the same interface and behavior as
<code>malloc</code>/<code>free</code>, except that for a SIMD FFTW they ensure
that the returned pointer has the necessary alignment (by calling
<code>memalign</code> or its equivalent on your OS).
</p>
<p>You are not <em>required</em> to use <code>fftw_malloc</code>. You can
allocate your data in any way that you like, from <code>malloc</code> to
<code>new</code> (in C++) to a fixed-size array declaration. If the array
happens not to be properly aligned, FFTW will not use the SIMD
extensions.
<span id="index-C_002b_002b-1"></span>
</p>
<span id="index-fftw_005falloc_005freal"></span>
<span id="index-fftw_005falloc_005fcomplex-1"></span>
<p>Since <code>fftw_malloc</code> only ever needs to be used for real and
complex arrays, we provide two convenient wrapper routines
<code>fftw_alloc_real(N)</code> and <code>fftw_alloc_complex(N)</code> that are
equivalent to <code>(double*)fftw_malloc(sizeof(double) * N)</code> and
<code>(fftw_complex*)fftw_malloc(sizeof(fftw_complex) * N)</code>,
respectively (or their equivalents in other precisions).
</p>
<hr>
<div class="header">
<p>
Next: <a href="Multi_002ddimensional-Array-Format.html" accesskey="n" rel="next">Multi-dimensional Array Format</a>, Previous: <a href="Other-Important-Topics.html" accesskey="p" rel="prev">Other Important Topics</a>, Up: <a href="Other-Important-Topics.html" accesskey="u" rel="up">Other Important Topics</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

100
fftw-3.3.10/doc/html/The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html Normal file
View File

@@ -0,0 +1,100 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>The 1d Discrete Fourier Transform (DFT) (FFTW 3.3.10)</title>
<meta name="description" content="The 1d Discrete Fourier Transform (DFT) (FFTW 3.3.10)">
<meta name="keywords" content="The 1d Discrete Fourier Transform (DFT) (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="What-FFTW-Really-Computes.html" rel="up" title="What FFTW Really Computes">
<link href="The-1d-Real_002ddata-DFT.html" rel="next" title="The 1d Real-data DFT">
<link href="What-FFTW-Really-Computes.html" rel="prev" title="What FFTW Really Computes">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="The-1d-Discrete-Fourier-Transform-_0028DFT_0029"></span><div class="header">
<p>
Next: <a href="The-1d-Real_002ddata-DFT.html" accesskey="n" rel="next">The 1d Real-data DFT</a>, Previous: <a href="What-FFTW-Really-Computes.html" accesskey="p" rel="prev">What FFTW Really Computes</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="The-1d-Discrete-Fourier-Transform-_0028DFT_0029-1"></span><h4 class="subsection">4.8.1 The 1d Discrete Fourier Transform (DFT)</h4>
<span id="index-discrete-Fourier-transform-1"></span>
<span id="index-DFT-2"></span>
<p>The forward (<code>FFTW_FORWARD</code>) discrete Fourier transform (DFT) of a
1d complex array <em>X</em> of size <em>n</em> computes an array <em>Y</em>,
where:
<center><img src="equation-dft.png" align="top">.</center>
The backward (<code>FFTW_BACKWARD</code>) DFT computes:
<center><img src="equation-idft.png" align="top">.</center>
</p>
<span id="index-normalization-8"></span>
<p>FFTW computes an unnormalized transform, in that there is no coefficient
in front of the summation in the DFT. In other words, applying the
forward and then the backward transform will multiply the input by
<em>n</em>.
</p>
<span id="index-frequency-1"></span>
<p>From above, an <code>FFTW_FORWARD</code> transform corresponds to a sign of
<em>-1</em> in the exponent of the DFT. Note also that we use the
standard &ldquo;in-order&rdquo; output ordering&mdash;the <em>k</em>-th output
corresponds to the frequency <em>k/n</em> (or <em>k/T</em>, where <em>T</em>
is your total sampling period). For those who like to think in terms of
positive and negative frequencies, this means that the positive
frequencies are stored in the first half of the output and the negative
frequencies are stored in backwards order in the second half of the
output. (The frequency <em>-k/n</em> is the same as the frequency
<em>(n-k)/n</em>.)
</p>
</body>
</html>

115
fftw-3.3.10/doc/html/The-1d-Real_002ddata-DFT.html Normal file
View File

@@ -0,0 +1,115 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>The 1d Real-data DFT (FFTW 3.3.10)</title>
<meta name="description" content="The 1d Real-data DFT (FFTW 3.3.10)">
<meta name="keywords" content="The 1d Real-data DFT (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="What-FFTW-Really-Computes.html" rel="up" title="What FFTW Really Computes">
<link href="1d-Real_002deven-DFTs-_0028DCTs_0029.html" rel="next" title="1d Real-even DFTs (DCTs)">
<link href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html" rel="prev" title="The 1d Discrete Fourier Transform (DFT)">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="The-1d-Real_002ddata-DFT"></span><div class="header">
<p>
Next: <a href="1d-Real_002deven-DFTs-_0028DCTs_0029.html" accesskey="n" rel="next">1d Real-even DFTs (DCTs)</a>, Previous: <a href="The-1d-Discrete-Fourier-Transform-_0028DFT_0029.html" accesskey="p" rel="prev">The 1d Discrete Fourier Transform (DFT)</a>, Up: <a href="What-FFTW-Really-Computes.html" accesskey="u" rel="up">What FFTW Really Computes</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="The-1d-Real_002ddata-DFT-1"></span><h4 class="subsection">4.8.2 The 1d Real-data DFT</h4>
<p>The real-input (r2c) DFT in FFTW computes the <em>forward</em> transform
<em>Y</em> of the size <code>n</code> real array <em>X</em>, exactly as defined
above, i.e.
<center><img src="equation-dft.png" align="top">.</center>
This output array <em>Y</em> can easily be shown to possess the
&ldquo;Hermitian&rdquo; symmetry
<span id="index-Hermitian-1"></span>
<i>Y<sub>k</sub> = Y<sub>n-k</sub></i><sup>*</sup>,
where we take <em>Y</em> to be periodic so that
<i>Y<sub>n</sub> = Y</i><sub>0</sub>.
</p>
<p>As a result of this symmetry, half of the output <em>Y</em> is redundant
(being the complex conjugate of the other half), and so the 1d r2c
transforms only output elements <em>0</em>&hellip;<em>n/2</em> of <em>Y</em>
(<em>n/2+1</em> complex numbers), where the division by <em>2</em> is
rounded down.
</p>
<p>Moreover, the Hermitian symmetry implies that
<i>Y</i><sub>0</sub>
and, if <em>n</em> is even, the
<i>Y</i><sub><i>n</i>/2</sub>
element, are purely real. So, for the <code>R2HC</code> r2r transform, the
halfcomplex format does not store the imaginary parts of these elements.
<span id="index-r2r-2"></span>
<span id="index-R2HC"></span>
<span id="index-halfcomplex-format-2"></span>
</p>
<p>The c2r and <code>H2RC</code> r2r transforms compute the backward DFT of the
<em>complex</em> array <em>X</em> with Hermitian symmetry, stored in the
r2c/<code>R2HC</code> output formats, respectively, where the backward
transform is defined exactly as for the complex case:
<center><img src="equation-idft.png" align="top">.</center>
The outputs <code>Y</code> of this transform can easily be seen to be purely
real, and are stored as an array of real numbers.
</p>
<span id="index-normalization-9"></span>
<p>Like FFTW&rsquo;s complex DFT, these transforms are unnormalized. In other
words, applying the real-to-complex (forward) and then the
complex-to-real (backward) transform will multiply the input by
<em>n</em>.
</p>
</body>
</html>

129
fftw-3.3.10/doc/html/The-Discrete-Hartley-Transform.html Normal file
View File

@@ -0,0 +1,129 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>The Discrete Hartley Transform (FFTW 3.3.10)</title>
<meta name="description" content="The Discrete Hartley Transform (FFTW 3.3.10)">
<meta name="keywords" content="The Discrete Hartley Transform (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="More-DFTs-of-Real-Data.html" rel="up" title="More DFTs of Real Data">
<link href="Other-Important-Topics.html" rel="next" title="Other Important Topics">
<link href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html" rel="prev" title="Real even/odd DFTs (cosine/sine transforms)">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="The-Discrete-Hartley-Transform"></span><div class="header">
<p>
Previous: <a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html" accesskey="p" rel="prev">Real even/odd DFTs (cosine/sine transforms)</a>, Up: <a href="More-DFTs-of-Real-Data.html" accesskey="u" rel="up">More DFTs of Real Data</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="The-Discrete-Hartley-Transform-1"></span><h4 class="subsection">2.5.3 The Discrete Hartley Transform</h4>
<p>If you are planning to use the DHT because you&rsquo;ve heard that it is
&ldquo;faster&rdquo; than the DFT (FFT), <strong>stop here</strong>. The DHT is not
faster than the DFT. That story is an old but enduring misconception
that was debunked in 1987.
</p>
<p>The discrete Hartley transform (DHT) is an invertible linear transform
closely related to the DFT. In the DFT, one multiplies each input by
<em>cos - i * sin</em> (a complex exponential), whereas in the DHT each
input is multiplied by simply <em>cos + sin</em>. Thus, the DHT
transforms <code>n</code> real numbers to <code>n</code> real numbers, and has the
convenient property of being its own inverse. In FFTW, a DHT (of any
positive <code>n</code>) can be specified by an r2r kind of <code>FFTW_DHT</code>.
<span id="index-FFTW_005fDHT"></span>
<span id="index-discrete-Hartley-transform"></span>
<span id="index-DHT"></span>
</p>
<p>Like the DFT, in FFTW the DHT is unnormalized, so computing a DHT of
size <code>n</code> followed by another DHT of the same size will result in
the original array multiplied by <code>n</code>.
<span id="index-normalization-4"></span>
</p>
<p>The DHT was originally proposed as a more efficient alternative to the
DFT for real data, but it was subsequently shown that a specialized DFT
(such as FFTW&rsquo;s r2hc or r2c transforms) could be just as fast. In FFTW,
the DHT is actually computed by post-processing an r2hc transform, so
there is ordinarily no reason to prefer it from a performance
perspective.<a id="DOCF5" href="#FOOT5"><sup>5</sup></a>
However, we have heard rumors that the DHT might be the most appropriate
transform in its own right for certain applications, and we would be
very interested to hear from anyone who finds it useful.
</p>
<p>If <code>FFTW_DHT</code> is specified for multiple dimensions of a
multi-dimensional transform, FFTW computes the separable product of 1d
DHTs along each dimension. Unfortunately, this is not quite the same
thing as a true multi-dimensional DHT; you can compute the latter, if
necessary, with at most <code>rank-1</code> post-processing passes
[see e.g. H. Hao and R. N. Bracewell, <i>Proc. IEEE</i> <b>75</b>, 264&ndash;266 (1987)].
</p>
<p>For the precise mathematical definition of the DHT as used by FFTW, see
<a href="What-FFTW-Really-Computes.html">What FFTW Really Computes</a>.
</p>
<div class="footnote">
<hr>
<h4 class="footnotes-heading">Footnotes</h4>
<h5><a id="FOOT5" href="#DOCF5">(5)</a></h3>
<p>We provide the DHT mainly as a byproduct of some
internal algorithms. FFTW computes a real input/output DFT of
<em>prime</em> size by re-expressing it as a DHT plus post/pre-processing
and then using Rader&rsquo;s prime-DFT algorithm adapted to the DHT.</p>
</div>
<hr>
<div class="header">
<p>
Previous: <a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html" accesskey="p" rel="prev">Real even/odd DFTs (cosine/sine transforms)</a>, Up: <a href="More-DFTs-of-Real-Data.html" accesskey="u" rel="up">More DFTs of Real Data</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

136
fftw-3.3.10/doc/html/The-Halfcomplex_002dformat-DFT.html Normal file
View File

@@ -0,0 +1,136 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- This manual is for FFTW
(version 3.3.10, 10 December 2020).
Copyright (C) 2003 Matteo Frigo.
Copyright (C) 2003 Massachusetts Institute of Technology.
Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that this permission notice may be stated in a translation
approved by the Free Software Foundation. -->
<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>The Halfcomplex-format DFT (FFTW 3.3.10)</title>
<meta name="description" content="The Halfcomplex-format DFT (FFTW 3.3.10)">
<meta name="keywords" content="The Halfcomplex-format DFT (FFTW 3.3.10)">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<link href="index.html" rel="start" title="Top">
<link href="Concept-Index.html" rel="index" title="Concept Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="More-DFTs-of-Real-Data.html" rel="up" title="More DFTs of Real Data">
<link href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html" rel="next" title="Real even/odd DFTs (cosine/sine transforms)">
<link href="More-DFTs-of-Real-Data.html" rel="prev" title="More DFTs of Real Data">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.indentedblock {margin-right: 0em}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
kbd {font-style: oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
span.nolinebreak {white-space: nowrap}
span.roman {font-family: initial; font-weight: normal}
span.sansserif {font-family: sans-serif; font-weight: normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en">
<span id="The-Halfcomplex_002dformat-DFT"></span><div class="header">
<p>
Next: <a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html" accesskey="n" rel="next">Real even/odd DFTs (cosine/sine transforms)</a>, Previous: <a href="More-DFTs-of-Real-Data.html" accesskey="p" rel="prev">More DFTs of Real Data</a>, Up: <a href="More-DFTs-of-Real-Data.html" accesskey="u" rel="up">More DFTs of Real Data</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<span id="The-Halfcomplex_002dformat-DFT-1"></span><h4 class="subsection">2.5.1 The Halfcomplex-format DFT</h4>
<p>An r2r kind of <code>FFTW_R2HC</code> (<em>r2hc</em>) corresponds to an r2c DFT
<span id="index-FFTW_005fR2HC"></span>
<span id="index-r2c-1"></span>
<span id="index-r2hc"></span>
(see <a href="One_002dDimensional-DFTs-of-Real-Data.html">One-Dimensional DFTs of Real Data</a>) but with &ldquo;halfcomplex&rdquo;
format output, and may sometimes be faster and/or more convenient than
the latter.
<span id="index-halfcomplex-format-1"></span>
The inverse <em>hc2r</em> transform is of kind <code>FFTW_HC2R</code>.
<span id="index-FFTW_005fHC2R"></span>
<span id="index-hc2r"></span>
This consists of the non-redundant half of the complex output for a 1d
real-input DFT of size <code>n</code>, stored as a sequence of <code>n</code> real
numbers (<code>double</code>) in the format:
</p>
<p align=center>
r<sub>0</sub>, r<sub>1</sub>, r<sub>2</sub>, ..., r<sub>n/2</sub>, i<sub>(n+1)/2-1</sub>, ..., i<sub>2</sub>, i<sub>1</sub>
</p>
<p>Here,
r<sub>k</sub>
is the real part of the <em>k</em>th output, and
i<sub>k</sub>
is the imaginary part. (Division by 2 is rounded down.) For a
halfcomplex array <code>hc[n]</code>, the <em>k</em>th component thus has its
real part in <code>hc[k]</code> and its imaginary part in <code>hc[n-k]</code>, with
the exception of <code>k</code> <code>==</code> <code>0</code> or <code>n/2</code> (the latter
only if <code>n</code> is even)&mdash;in these two cases, the imaginary part is
zero due to symmetries of the real-input DFT, and is not stored.
Thus, the r2hc transform of <code>n</code> real values is a halfcomplex array of
length <code>n</code>, and vice versa for hc2r.
<span id="index-normalization-2"></span>
</p>
<p>Aside from the differing format, the output of
<code>FFTW_R2HC</code>/<code>FFTW_HC2R</code> is otherwise exactly the same as for
the corresponding 1d r2c/c2r transform
(i.e. <code>FFTW_FORWARD</code>/<code>FFTW_BACKWARD</code> transforms, respectively).
Recall that these transforms are unnormalized, so r2hc followed by hc2r
will result in the original data multiplied by <code>n</code>. Furthermore,
like the c2r transform, an out-of-place hc2r transform will
<em>destroy its input</em> array.
</p>
<p>Although these halfcomplex transforms can be used with the
multi-dimensional r2r interface, the interpretation of such a separable
product of transforms along each dimension is problematic. For example,
consider a two-dimensional <code>n0</code> by <code>n1</code>, r2hc by r2hc
transform planned by <code>fftw_plan_r2r_2d(n0, n1, in, out, FFTW_R2HC,
FFTW_R2HC, FFTW_MEASURE)</code>. Conceptually, FFTW first transforms the rows
(of size <code>n1</code>) to produce halfcomplex rows, and then transforms the
columns (of size <code>n0</code>). Half of these column transforms, however,
are of imaginary parts, and should therefore be multiplied by <em>i</em>
and combined with the r2hc transforms of the real columns to produce the
2d DFT amplitudes; FFTW&rsquo;s r2r transform does <em>not</em> perform this
combination for you. Thus, if a multi-dimensional real-input/output DFT
is required, we recommend using the ordinary r2c/c2r
interface (see <a href="Multi_002dDimensional-DFTs-of-Real-Data.html">Multi-Dimensional DFTs of Real Data</a>).
</p>
<hr>
<div class="header">
<p>
Next: <a href="Real-even_002fodd-DFTs-_0028cosine_002fsine-transforms_0029.html" accesskey="n" rel="next">Real even/odd DFTs (cosine/sine transforms)</a>, Previous: <a href="More-DFTs-of-Real-Data.html" accesskey="p" rel="prev">More DFTs of Real Data</a>, Up: <a href="More-DFTs-of-Real-Data.html" accesskey="u" rel="up">More DFTs of Real Data</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More