linuxx86_64/0000755003427200235140000000000010054440506011436 5ustar jimnamdlinuxx86_64/include/0000755003427200235140000000000010054475345013072 5ustar jimnamdlinuxx86_64/include/srfftw.h0000644003427200235140000000726510015476203014557 0ustar jimnamd/*
* Copyright (c) 19971999 Massachusetts Institute of Technology
*
* This program 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.
*
* 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.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 021111307 USA
*
*/
/* rfftw.h  systemwide definitions for rfftw */
#ifndef RFFTW_H
#define RFFTW_H
#include
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/****************************************************************************/
#define RFFTW_V2
typedef fftw_plan rfftw_plan;
typedef fftwnd_plan rfftwnd_plan;
#define FFTW_REAL_TO_COMPLEX FFTW_FORWARD
#define FFTW_COMPLEX_TO_REAL FFTW_BACKWARD
extern void rfftw(rfftw_plan plan, int howmany, fftw_real *in, int istride,
int idist, fftw_real *out, int ostride, int odist);
extern void rfftw_one(rfftw_plan plan, fftw_real *in, fftw_real *out);
extern rfftw_plan rfftw_create_plan_specific(int n, fftw_direction dir,
int flags,
fftw_real *in, int istride,
fftw_real *out, int ostride);
extern rfftw_plan rfftw_create_plan(int n, fftw_direction dir, int flags);
extern void rfftw_destroy_plan(rfftw_plan plan);
extern void rfftw_fprint_plan(FILE *f, rfftw_plan p);
extern void rfftw_print_plan(rfftw_plan p);
extern void rfftw_executor_simple(int n, fftw_real *in,
fftw_real *out,
fftw_plan_node *p,
int istride,
int ostride,
fftw_recurse_kind recurse_kind);
extern rfftwnd_plan rfftwnd_create_plan_specific(int rank, const int *n,
fftw_direction dir, int flags,
fftw_real *in, int istride,
fftw_real *out, int ostride);
extern rfftwnd_plan rfftw2d_create_plan_specific(int nx, int ny,
fftw_direction dir, int flags,
fftw_real *in, int istride,
fftw_real *out, int ostride);
extern rfftwnd_plan rfftw3d_create_plan_specific(int nx, int ny, int nz,
fftw_direction dir, int flags,
fftw_real *in, int istride,
fftw_real *out, int ostride);
extern rfftwnd_plan rfftwnd_create_plan(int rank, const int *n,
fftw_direction dir, int flags);
extern rfftwnd_plan rfftw2d_create_plan(int nx, int ny,
fftw_direction dir, int flags);
extern rfftwnd_plan rfftw3d_create_plan(int nx, int ny, int nz,
fftw_direction dir, int flags);
extern void rfftwnd_destroy_plan(rfftwnd_plan plan);
extern void rfftwnd_fprint_plan(FILE *f, rfftwnd_plan plan);
extern void rfftwnd_print_plan(rfftwnd_plan plan);
extern void rfftwnd_real_to_complex(rfftwnd_plan p, int howmany,
fftw_real *in, int istride, int idist,
fftw_complex *out, int ostride, int odist);
extern void rfftwnd_complex_to_real(rfftwnd_plan p, int howmany,
fftw_complex *in, int istride, int idist,
fftw_real *out, int ostride, int odist);
extern void rfftwnd_one_real_to_complex(rfftwnd_plan p,
fftw_real *in, fftw_complex *out);
extern void rfftwnd_one_complex_to_real(rfftwnd_plan p,
fftw_complex *in, fftw_real *out);
/****************************************************************************/
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* RFFTW_H */
linuxx86_64/include/sfftw.h0000644003427200235140000003025310015476202014365 0ustar jimnamd/* fftw/fftw.h. Generated automatically by configure. */
/* * C * */
/*
* Copyright (c) 19971999 Massachusetts Institute of Technology
*
* This program 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.
*
* 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.
*
* 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., 59 Temple Place, Suite 330, Boston, MA 021111307 USA
*
*/
/* fftw.h  systemwide definitions */
/* $Id: fftw.h.in,v 1.53 1999/07/24 20:01:23 stevenj Exp $ */
#ifndef FFTW_H
#define FFTW_H
#include
#include
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
/* Define for using single precision */
/*
* If you can, use configure enablefloat instead of changing this
* flag directly
*/
#define FFTW_ENABLE_FLOAT 1
/* our real numbers */
#ifdef FFTW_ENABLE_FLOAT
typedef float fftw_real;
#else
typedef double fftw_real;
#endif
/*********************************************
* Complex numbers and operations
*********************************************/
typedef struct {
fftw_real re, im;
} fftw_complex;
#define c_re(c) ((c).re)
#define c_im(c) ((c).im)
typedef enum {
FFTW_FORWARD = 1, FFTW_BACKWARD = 1
} fftw_direction;
/* backward compatibility with FFTW1.3 */
typedef fftw_complex FFTW_COMPLEX;
typedef fftw_real FFTW_REAL;
#ifndef FFTW_1_0_COMPATIBILITY
#define FFTW_1_0_COMPATIBILITY 0
#endif
#if FFTW_1_0_COMPATIBILITY
/* backward compatibility with FFTW1.0 */
#define REAL fftw_real
#define COMPLEX fftw_complex
#endif
/*********************************************
* Success or failure status
*********************************************/
typedef enum {
FFTW_SUCCESS = 0, FFTW_FAILURE = 1
} fftw_status;
/*********************************************
* Codelets
*********************************************/
typedef void (fftw_notw_codelet)
(const fftw_complex *, fftw_complex *, int, int);
typedef void (fftw_twiddle_codelet)
(fftw_complex *, const fftw_complex *, int,
int, int);
typedef void (fftw_generic_codelet)
(fftw_complex *, const fftw_complex *, int,
int, int, int);
typedef void (fftw_real2hc_codelet)
(const fftw_real *, fftw_real *, fftw_real *,
int, int, int);
typedef void (fftw_hc2real_codelet)
(const fftw_real *, const fftw_real *,
fftw_real *, int, int, int);
typedef void (fftw_hc2hc_codelet)
(fftw_real *, const fftw_complex *,
int, int, int);
typedef void (fftw_rgeneric_codelet)
(fftw_real *, const fftw_complex *, int,
int, int, int);
/*********************************************
* Configurations
*********************************************/
/*
* A configuration is a database of all known codelets
*/
enum fftw_node_type {
FFTW_NOTW, FFTW_TWIDDLE, FFTW_GENERIC, FFTW_RADER,
FFTW_REAL2HC, FFTW_HC2REAL, FFTW_HC2HC, FFTW_RGENERIC
};
/* description of a codelet */
typedef struct {
const char *name; /* name of the codelet */
void (*codelet) (); /* pointer to the codelet itself */
int size; /* size of the codelet */
fftw_direction dir; /* direction */
enum fftw_node_type type; /* TWIDDLE or NO_TWIDDLE */
int signature; /* unique id */
int ntwiddle; /* number of twiddle factors */
const int *twiddle_order; /*
* array that determines the order
* in which the codelet expects
* the twiddle factors
*/
} fftw_codelet_desc;
/* On Win32, you need to do funny things to access global variables
in shared libraries. Thanks to Andrew Sterian for this hack. */
#ifdef HAVE_WIN32
# if defined(BUILD_FFTW_DLL)
# define DL_IMPORT(type) __declspec(dllexport) type
# elif defined(USE_FFTW_DLL)
# define DL_IMPORT(type) __declspec(dllimport) type
# else
# define DL_IMPORT(type) type
# endif
#else
# define DL_IMPORT(type) type
#endif
extern DL_IMPORT(const char *) fftw_version;
/*****************************
* Plans
*****************************/
/*
* A plan is a sequence of reductions to compute a FFT of
* a given size. At each step, the FFT algorithm can:
*
* 1) apply a notw codelet, or
* 2) recurse and apply a twiddle codelet, or
* 3) apply the generic codelet.
*/
/* structure that contains twiddle factors */
typedef struct fftw_twiddle_struct {
int n;
const fftw_codelet_desc *cdesc;
fftw_complex *twarray;
struct fftw_twiddle_struct *next;
int refcnt;
} fftw_twiddle;
typedef struct fftw_rader_data_struct {
struct fftw_plan_struct *plan;
fftw_complex *omega;
int g, ginv;
int p, flags, refcount;
struct fftw_rader_data_struct *next;
fftw_codelet_desc *cdesc;
} fftw_rader_data;
typedef void (fftw_rader_codelet)
(fftw_complex *, const fftw_complex *, int,
int, int, fftw_rader_data *);
/* structure that holds all the data needed for a given step */
typedef struct fftw_plan_node_struct {
enum fftw_node_type type;
union {
/* nodes of type FFTW_NOTW */
struct {
int size;
fftw_notw_codelet *codelet;
const fftw_codelet_desc *codelet_desc;
} notw;
/* nodes of type FFTW_TWIDDLE */
struct {
int size;
fftw_twiddle_codelet *codelet;
fftw_twiddle *tw;
struct fftw_plan_node_struct *recurse;
const fftw_codelet_desc *codelet_desc;
} twiddle;
/* nodes of type FFTW_GENERIC */
struct {
int size;
fftw_generic_codelet *codelet;
fftw_twiddle *tw;
struct fftw_plan_node_struct *recurse;
} generic;
/* nodes of type FFTW_RADER */
struct {
int size;
fftw_rader_codelet *codelet;
fftw_rader_data *rader_data;
fftw_twiddle *tw;
struct fftw_plan_node_struct *recurse;
} rader;
/* nodes of type FFTW_REAL2HC */
struct {
int size;
fftw_real2hc_codelet *codelet;
const fftw_codelet_desc *codelet_desc;
} real2hc;
/* nodes of type FFTW_HC2REAL */
struct {
int size;
fftw_hc2real_codelet *codelet;
const fftw_codelet_desc *codelet_desc;
} hc2real;
/* nodes of type FFTW_HC2HC */
struct {
int size;
fftw_direction dir;
fftw_hc2hc_codelet *codelet;
fftw_twiddle *tw;
struct fftw_plan_node_struct *recurse;
const fftw_codelet_desc *codelet_desc;
} hc2hc;
/* nodes of type FFTW_RGENERIC */
struct {
int size;
fftw_direction dir;
fftw_rgeneric_codelet *codelet;
fftw_twiddle *tw;
struct fftw_plan_node_struct *recurse;
} rgeneric;
} nodeu;
int refcnt;
} fftw_plan_node;
typedef enum {
FFTW_NORMAL_RECURSE = 0,
FFTW_VECTOR_RECURSE = 1
} fftw_recurse_kind;
struct fftw_plan_struct {
int n;
int refcnt;
fftw_direction dir;
int flags;
int wisdom_signature;
enum fftw_node_type wisdom_type;
struct fftw_plan_struct *next;
fftw_plan_node *root;
double cost;
fftw_recurse_kind recurse_kind;
int vector_size;
};
typedef struct fftw_plan_struct *fftw_plan;
/* flags for the planner */
#define FFTW_ESTIMATE (0)
#define FFTW_MEASURE (1)
#define FFTW_OUT_OF_PLACE (0)
#define FFTW_IN_PLACE (8)
#define FFTW_USE_WISDOM (16)
#define FFTW_THREADSAFE (128) /* guarantee plan is readonly so that the
same plan can be used in parallel by
multiple threads */
#define FFTWND_FORCE_BUFFERED (256) /* internal flag, forces buffering
in fftwnd transforms */
#define FFTW_NO_VECTOR_RECURSE (512) /* internal flag, prevents use
of vector recursion */
extern fftw_plan fftw_create_plan_specific(int n, fftw_direction dir,
int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
#define FFTW_HAS_PLAN_SPECIFIC
extern fftw_plan fftw_create_plan(int n, fftw_direction dir, int flags);
extern void fftw_print_plan(fftw_plan plan);
extern void fftw_destroy_plan(fftw_plan plan);
extern void fftw(fftw_plan plan, int howmany, fftw_complex *in, int istride,
int idist, fftw_complex *out, int ostride, int odist);
extern void fftw_one(fftw_plan plan, fftw_complex *in, fftw_complex *out);
extern void fftw_die(const char *s);
extern void *fftw_malloc(size_t n);
extern void fftw_free(void *p);
extern void fftw_check_memory_leaks(void);
extern void fftw_print_max_memory_usage(void);
typedef void *(*fftw_malloc_type_function) (size_t n);
typedef void (*fftw_free_type_function) (void *p);
typedef void (*fftw_die_type_function) (const char *errString);
extern DL_IMPORT(fftw_malloc_type_function) fftw_malloc_hook;
extern DL_IMPORT(fftw_free_type_function) fftw_free_hook;
extern DL_IMPORT(fftw_die_type_function) fftw_die_hook;
extern size_t fftw_sizeof_fftw_real(void);
/* Wisdom: */
/*
* define this symbol so that users know we are using a version of FFTW
* with wisdom
*/
#define FFTW_HAS_WISDOM
extern void fftw_forget_wisdom(void);
extern void fftw_export_wisdom(void (*emitter) (char c, void *), void *data);
extern fftw_status fftw_import_wisdom(int (*g) (void *), void *data);
extern void fftw_export_wisdom_to_file(FILE *output_file);
extern fftw_status fftw_import_wisdom_from_file(FILE *input_file);
extern char *fftw_export_wisdom_to_string(void);
extern fftw_status fftw_import_wisdom_from_string(const char *input_string);
/*
* define symbol so we know this function is available (it is not in
* older FFTWs)
*/
#define FFTW_HAS_FPRINT_PLAN
extern void fftw_fprint_plan(FILE *f, fftw_plan plan);
/*****************************
* Ndimensional code
*****************************/
typedef struct {
int is_in_place; /* 1 if for inplace FFTs, 0 otherwise */
int rank; /*
* the rank (number of dimensions) of the
* array to be FFTed
*/
int *n; /*
* the dimensions of the array to the
* FFTed
*/
fftw_direction dir;
int *n_before; /*
* n_before[i] = product of n[j] for j < i
*/
int *n_after; /* n_after[i] = product of n[j] for j > i */
fftw_plan *plans; /* 1d fftw plans for each dimension */
int nbuffers, nwork;
fftw_complex *work; /*
* work array big enough to hold
* nbuffers+1 of the largest dimension
* (has nwork elements)
*/
} fftwnd_data;
typedef fftwnd_data *fftwnd_plan;
/* Initializing the FFTWND plan: */
extern fftwnd_plan fftw2d_create_plan(int nx, int ny, fftw_direction dir,
int flags);
extern fftwnd_plan fftw3d_create_plan(int nx, int ny, int nz,
fftw_direction dir, int flags);
extern fftwnd_plan fftwnd_create_plan(int rank, const int *n,
fftw_direction dir,
int flags);
extern fftwnd_plan fftw2d_create_plan_specific(int nx, int ny,
fftw_direction dir,
int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
extern fftwnd_plan fftw3d_create_plan_specific(int nx, int ny, int nz,
fftw_direction dir, int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
extern fftwnd_plan fftwnd_create_plan_specific(int rank, const int *n,
fftw_direction dir,
int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
/* Freeing the FFTWND plan: */
extern void fftwnd_destroy_plan(fftwnd_plan plan);
/* Printing the plan: */
extern void fftwnd_fprint_plan(FILE *f, fftwnd_plan p);
extern void fftwnd_print_plan(fftwnd_plan p);
#define FFTWND_HAS_PRINT_PLAN
/* Computing the NDimensional FFT */
extern void fftwnd(fftwnd_plan plan, int howmany,
fftw_complex *in, int istride, int idist,
fftw_complex *out, int ostride, int odist);
extern void fftwnd_one(fftwnd_plan p, fftw_complex *in, fftw_complex *out);
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* FFTW_H */
linuxx86_64/info/0000755003427200235140000000000010054451554012376 5ustar jimnamdlinuxx86_64/info/fftw.info0000644003427200235140000000745010015476203014222 0ustar jimnamdThis is Info file fftw.info, produced by Makeinfo version 1.68 from the
input file fftw.texi.
This is the FFTW User's manual.
Copyright (C) 19971999 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.
Indirect:
fftw.info1: 871
fftw.info2: 49529
fftw.info3: 98154
fftw.info4: 147774
fftw.info5: 194232
Tag Table:
(Indirect)
Node: Top871
Node: Introduction4285
Node: Tutorial10632
Node: Complex Onedimensional Transforms Tutorial12861
Node: Complex Multidimensional Transforms Tutorial16345
Node: Real Onedimensional Transforms Tutorial20047
Node: Real Multidimensional Transforms Tutorial25049
Node: Multidimensional Array Format33192
Node: Rowmajor Format33886
Node: Columnmajor Format35224
Node: Static Arrays in C36201
Node: Dynamic Arrays in C36690
Node: Dynamic Arrays in CThe Wrong Way38118
Node: Words of Wisdom39864
Node: Caveats in Using Wisdom44513
Node: Importing and Exporting Wisdom46020
Node: FFTW Reference49529
Node: Data Types50878
Node: Onedimensional Transforms Reference53627
Node: fftw_create_plan54301
Node: Discussion on Specific Plans60245
Node: fftw61589
Node: fftw_destroy_plan64240
Node: What FFTW Really Computes64673
Node: Multidimensional Transforms Reference66042
Node: fftwnd_create_plan66701
Node: fftwnd73511
Node: fftwnd_destroy_plan76476
Node: What FFTWND Really Computes76927
Node: Real Onedimensional Transforms Reference77809
Node: rfftw_create_plan78628
Node: rfftw83538
Node: rfftw_destroy_plan86137
Node: What RFFTW Really Computes86592
Node: Real Multidimensional Transforms Reference87982
Node: rfftwnd_create_plan88743
Node: rfftwnd93693
Node: Array Dimensions for Real Multidimensional Transforms98154
Node: Strides in Inplace RFFTWND100202
Node: rfftwnd_destroy_plan102594
Node: What RFFTWND Really Computes103077
Node: Wisdom Reference104015
Node: fftw_export_wisdom104281
Node: fftw_import_wisdom105928
Node: fftw_forget_wisdom107795
Node: Memory Allocator Reference108174
Node: Thread safety109257
Node: Parallel FFTW111170
Node: Multithreaded FFTW113264
Node: Installation and Supported Hardware/Software114162
Node: Usage of Multithreaded FFTW115672
Node: How Many Threads to Use?119885
Node: Using Multithreaded FFTW in a Multithreaded Program121551
Node: Tips for Optimal Threading122253
Node: MPI FFTW123868
Node: MPI FFTW Installation124710
Node: Usage of MPI FFTW for Complex Multidimensional Transforms126508
Node: MPI Data Layout131630
Node: Usage of MPI FFTW for Real Multidimensional Transforms136825
Node: Usage of MPI FFTW for Complex Onedimensional Transforms143243
Node: MPI Tips147774
Node: Calling FFTW from Fortran149766
Node: Wrapper Routines151194
Node: FFTW Constants in Fortran154536
Node: Fortran Examples156134
Node: Installation and Customization159823
Node: Installation on Unix161160
Node: Installation on nonUnix Systems165273
Node: Installing FFTW in both single and double precision167593
Node: gcc and Pentium hacks169277
Node: Customizing the timer171808
Node: Generating your own code173722
Node: Acknowledgments176371
Node: License and Copyright179226
Node: Concept Index180863
Node: Library Index194232
End Tag Table
linuxx86_64/info/fftw.info10000644003427200235140000014057110015476203014362 0ustar jimnamdThis is Info file fftw.info, produced by Makeinfo version 1.68 from the
input file fftw.texi.
This is the FFTW User's manual.
Copyright (C) 19971999 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.
File: fftw.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir)
FFTW User Manual
****************
Welcome to FFTW, the Fastest Fourier Transform in the West. FFTW is
a collection of fast C routines to compute the discrete Fourier
transform. This manual documents FFTW version 2.1.3.
* Menu:
* Introduction::
* Tutorial::
* FFTW Reference::
* Parallel FFTW::
* Calling FFTW from Fortran::
* Installation and Customization::
* Acknowledgments::
* License and Copyright::
* Concept Index::
* Library Index::
Tutorial
* Complex Onedimensional Transforms Tutorial::
* Complex Multidimensional Transforms Tutorial::
* Real Onedimensional Transforms Tutorial::
* Real Multidimensional Transforms Tutorial::
* Multidimensional Array Format::
* Words of Wisdom::
Multidimensional Array Format
* Rowmajor Format::
* Columnmajor Format::
* Static Arrays in C::
* Dynamic Arrays in C::
* Dynamic Arrays in CThe Wrong Way::
Words of Wisdom
* Caveats in Using Wisdom:: What you should worry about in using wisdom
* Importing and Exporting Wisdom:: I/O of wisdom to disk and other media
FFTW Reference
* Data Types:: real, complex, and halfcomplex numbers
* Onedimensional Transforms Reference::
* Multidimensional Transforms Reference::
* Real Onedimensional Transforms Reference::
* Real Multidimensional Transforms Reference::
* Wisdom Reference::
* Memory Allocator Reference::
* Thread safety::
Onedimensional Transforms Reference
* fftw_create_plan:: Plan Creation
* Discussion on Specific Plans::
* fftw:: Plan Execution
* fftw_destroy_plan:: Plan Destruction
* What FFTW Really Computes:: Definition of the DFT.
Multidimensional Transforms Reference
* fftwnd_create_plan:: Plan Creation
* fftwnd:: Plan Execution
* fftwnd_destroy_plan:: Plan Destruction
* What FFTWND Really Computes::
Real Onedimensional Transforms Reference
* rfftw_create_plan:: Plan Creation
* rfftw:: Plan Execution
* rfftw_destroy_plan:: Plan Destruction
* What RFFTW Really Computes::
Real Multidimensional Transforms Reference
* rfftwnd_create_plan:: Plan Creation
* rfftwnd:: Plan Execution
* Array Dimensions for Real Multidimensional Transforms::
* Strides in Inplace RFFTWND::
* rfftwnd_destroy_plan:: Plan Destruction
* What RFFTWND Really Computes::
Wisdom Reference
* fftw_export_wisdom::
* fftw_import_wisdom::
* fftw_forget_wisdom::
Parallel FFTW
* Multithreaded FFTW::
* MPI FFTW::
Multithreaded FFTW
* Installation and Supported Hardware/Software::
* Usage of Multithreaded FFTW::
* How Many Threads to Use?::
* Using Multithreaded FFTW in a Multithreaded Program::
* Tips for Optimal Threading::
MPI FFTW
* MPI FFTW Installation::
* Usage of MPI FFTW for Complex Multidimensional Transforms::
* MPI Data Layout::
* Usage of MPI FFTW for Real Multidimensional Transforms::
* Usage of MPI FFTW for Complex Onedimensional Transforms::
* MPI Tips::
Calling FFTW from Fortran
* Wrapper Routines::
* FFTW Constants in Fortran::
* Fortran Examples::
Installation and Customization
* Installation on Unix::
* Installation on nonUnix Systems::
* Installing FFTW in both single and double precision::
* gcc and Pentium hacks::
* Customizing the timer::
* Generating your own code::
File: fftw.info, Node: Introduction, Next: Tutorial, Prev: Top, Up: Top
Introduction
************
This manual documents version 2.1.3 of FFTW, the *Fastest Fourier
Transform in the West*. FFTW is a comprehensive collection of fast C
routines for computing the discrete Fourier transform (DFT) in one or
more dimensions, of both real and complex data, and of arbitrary input
size. FFTW also includes parallel transforms for both shared and
distributedmemory systems. We assume herein that the reader is already
familiar with the properties and uses of the DFT that are relevant to
her application. Otherwise, see e.g. `The Fast Fourier Transform' by
E. O. Brigham (PrenticeHall, Englewood Cliffs, NJ, 1974).
Our web page (http://www.fftw.org) also has links to FFTrelated
information online.
FFTW is usually faster (and sometimes much faster) than all other
freelyavailable Fourier transform programs found on the Net. For
transforms whose size is a power of two, it compares favorably with the
FFT codes in Sun's Performance Library and IBM's ESSL library, which are
targeted at specific machines. Moreover, FFTW's performance is
*portable*. Indeed, FFTW is unique in that it automatically adapts
itself to your machine, your cache, the size of your memory, the number
of registers, and all the other factors that normally make it impossible
to optimize a program for more than one machine. An extensive
comparison of FFTW's performance with that of other Fourier transform
codes has been made. The results are available on the Web at
the benchFFT home page (http://theory.lcs.mit.edu/~benchfft).
In order to use FFTW effectively, you need to understand one basic
concept of FFTW's internal structure. FFTW does not used a fixed
algorithm for computing the transform, but it can adapt the DFT
algorithm to details of the underlying hardware in order to achieve best
performance. Hence, the computation of the transform is split into two
phases. First, FFTW's "planner" is called, which "learns" the fastest
way to compute the transform on your machine. The planner produces a
data structure called a "plan" that contains this information.
Subsequently, the plan is passed to FFTW's "executor", along with an
array of input data. The executor computes the actual transform, as
dictated by the plan. The plan can be reused as many times as needed.
In typical highperformance applications, many transforms of the same
size are computed, and consequently a relativelyexpensive
initialization of this sort is acceptable. On the other hand, if you
need a single transform of a given size, the onetime cost of the
planner becomes significant. For this case, FFTW provides fast
planners based on heuristics or on previously computed plans.
The pattern of planning/execution applies to all four operation
modes of FFTW, that is, I) onedimensional complex transforms (FFTW),
II) multidimensional complex transforms (FFTWND), III) onedimensional
transforms of real data (RFFTW), IV) multidimensional transforms of
real data (RFFTWND). Each mode comes with its own planner and executor.
Besides the automatic performance adaptation performed by the
planner, it is also possible for advanced users to customize FFTW for
their special needs. As distributed, FFTW works most efficiently for
arrays whose size can be factored into small primes (2, 3, 5, and 7),
and uses a slower generalpurpose routine for other factors. FFTW,
however, comes with a code generator that can produce fast C programs
for any particular array size you may care about. For example, if you
need transforms of size 513 = 19 x 3^3, you can customize FFTW to
support the factor 19 efficiently.
FFTW can exploit multiple processors if you have them. FFTW comes
with a sharedmemory implementation on top of POSIX (and similar)
threads, as well as a distributedmemory implementation based on MPI.
We also provide an experimental parallel implementation written in Cilk,
*the superior programming tool of choice for discriminating hackers*
(Olin Shivers). (See the Cilk home page (http://supertech.lcs.mit.edu/cilk).)
For more information regarding FFTW, see the paper, "The Fastest
Fourier Transform in the West," by M. Frigo and S. G. Johnson, which is
the technical report MITLCSTR728 (Sep. '97). See also, "FFTW: An
Adaptive Software Architecture for the FFT," by M. Frigo and S. G.
Johnson, which appeared in the 23rd International Conference on
Acoustics, Speech, and Signal Processing (`Proc. ICASSP 1998' 3, p.
1381). The code generator is described in the paper "A Fast Fourier
Transform Compiler", by M. Frigo, to appear in the `Proceedings of the
1999 ACM SIGPLAN Conference on Programming Language Design and
Implementation (PLDI), Atlanta, Georgia, May 1999'. These papers,
along with the latest version of FFTW, the FAQ, benchmarks, and other
links, are available at the FFTW home page (http://www.fftw.org). 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
CooleyTukey algorithm, the Prime Factor algorithm, Rader's algorithm
for prime sizes, and the splitradix algorithm (with a variation due to
Dan Bernstein). Our code generator also produces new algorithms that
we do not yet completely understand. The reader is referred to the
cited papers for the appropriate references.
The rest of this manual is organized as follows. We first discuss
the sequential (oneprocessor) implementation. We start by describing
the basic features of FFTW in *Note Tutorial::. This discussion
includes the storage scheme of multidimensional arrays (*Note
Multidimensional Array Format::) and FFTW's mechanisms for storing
plans on disk (*Note Words of Wisdom::). Next, *Note FFTW Reference::
provides comprehensive documentation of all FFTW's features. Parallel
transforms are discussed in their own chapter *Note Parallel FFTW::.
Fortran programmers can also use FFTW, as described in *Note Calling
FFTW from Fortran::. *Note Installation and Customization:: explains
how to install FFTW in your computer system and how to adapt FFTW to
your needs. License and copyright information is given in *Note
License and Copyright::. Finally, we thank all the people who helped
us in *Note Acknowledgments::.
File: fftw.info, Node: Tutorial, Next: FFTW Reference, Prev: Introduction, Up: Top
Tutorial
********
This chapter describes the basic usage of FFTW, i.e., how to compute
the Fourier transform of a single array. This chapter tells the truth,
but not the *whole* truth. Specifically, FFTW implements additional
routines and flags, providing extra functionality, that are not
documented here. *Note FFTW Reference::, for more complete information.
(Note that you need to compile and install FFTW before you can use it in
a program. *Note Installation and Customization::, for the details of
the installation.)
Here, we assume a default installation of FFTW. In some
installations (particulary from binary packages), the FFTW header files
and libraries are prefixed with ``d'' or ``s'' to indicate versions in
double or single precision, respectively. The usage of FFTW in that
case is the same, except that `#include' directives and link commands
must use the appropriate prefix. *Note Installing FFTW in both single
and double precision::, for more information.
This tutorial chapter is structured as follows. *Note Complex
Onedimensional Transforms Tutorial:: describes the basic usage of the
onedimensional transform of complex data. *Note Complex
Multidimensional Transforms Tutorial:: describes the basic usage of the
multidimensional transform of complex data. *Note Real
Onedimensional Transforms Tutorial:: describes the onedimensional
transform of real data and its inverse. Finally, *Note Real
Multidimensional Transforms Tutorial:: describes the multidimensional
transform of real data and its inverse. We recommend that you read
these sections in the order that they are presented. We then discuss
two topics in detail. In *Note Multidimensional Array Format::, we
discuss the various alternatives for storing multidimensional arrays
in memory. *Note Words of Wisdom:: shows how you can save FFTW's plans
for future use.
* Menu:
* Complex Onedimensional Transforms Tutorial::
* Complex Multidimensional Transforms Tutorial::
* Real Onedimensional Transforms Tutorial::
* Real Multidimensional Transforms Tutorial::
* Multidimensional Array Format::
* Words of Wisdom::
File: fftw.info, Node: Complex Onedimensional Transforms Tutorial, Next: Complex Multidimensional Transforms Tutorial, Prev: Tutorial, Up: Tutorial
Complex Onedimensional Transforms Tutorial
===========================================
The basic usage of FFTW is simple. A typical call to FFTW looks
like:
#include
...
{
fftw_complex in[N], out[N];
fftw_plan p;
...
p = fftw_create_plan(N, FFTW_FORWARD, FFTW_ESTIMATE);
...
fftw_one(p, in, out);
...
fftw_destroy_plan(p);
}
The first thing we do is to create a "plan", which is an object that
contains all the data that FFTW needs to compute the FFT, using the
following function:
fftw_plan fftw_create_plan(int n, fftw_direction dir, int flags);
The first argument, `n', is the size of the transform you are trying
to compute. The size `n' can be any positive integer, but sizes that
are products of small factors are transformed most efficiently. The
second argument, `dir', can be either `FFTW_FORWARD' or
`FFTW_BACKWARD', and indicates the direction of the transform you are
interested in. Alternatively, you can use the sign of the exponent in
the transform, 1 or +1, which corresponds to `FFTW_FORWARD' or
`FFTW_BACKWARD' respectively. The `flags' argument is either
`FFTW_MEASURE' or `FFTW_ESTIMATE'. `FFTW_MEASURE' means that FFTW
actually runs and measures the execution time of several FFTs in order
to find the best way to compute the transform of size `n'. This may
take some time, depending on your installation and on the precision of
the timer in your machine. `FFTW_ESTIMATE', on the contrary, does not
run any computation, and just builds a reasonable plan, which may be
suboptimal. In other words, if your program performs many transforms
of the same size and initialization time is not important, use
`FFTW_MEASURE'; otherwise use the estimate. (A compromise between
these two extremes exists. *Note Words of Wisdom::.)
Once the plan has been created, you can use it as many times as you
like for transforms on arrays of the same size. When you are done with
the plan, you deallocate it by calling `fftw_destroy_plan(plan)'.
The transform itself is computed by passing the plan along with the
input and output arrays to `fftw_one':
void fftw_one(fftw_plan plan, fftw_complex *in, fftw_complex *out);
Note that the transform is out of place: `in' and `out' must point
to distinct arrays. It operates on data of type `fftw_complex', a data
structure with real (`in[i].re') and imaginary (`in[i].im')
floatingpoint components. The `in' and `out' arrays should have the
length specified when the plan was created. An alternative function,
`fftw', allows you to efficiently perform multiple and/or strided
transforms (*note FFTW Reference::.).
The DFT results are stored inorder in the array `out', with the
zerofrequency (DC) component in `out[0]'. The array `in' is not
modified. Users should note that FFTW computes an unnormalized DFT,
the sign of whose exponent is given by the `dir' parameter of
`fftw_create_plan'. Thus, computing a forward followed by a backward
transform (or vice versa) results in the original array scaled by `n'.
*Note What FFTW Really Computes::, for the definition of DFT.
A program using FFTW should be linked with `lfftw lm' on Unix
systems, or with the FFTW and standard math libraries in general.
File: fftw.info, Node: Complex Multidimensional Transforms Tutorial, Next: Real Onedimensional Transforms Tutorial, Prev: Complex Onedimensional Transforms Tutorial, Up: Tutorial
Complex Multidimensional Transforms Tutorial
=============================================
FFTW can also compute transforms of any number of dimensions
("rank"). The syntax is similar to that for the onedimensional
transforms, with `fftw_' replaced by `fftwnd_' (which stands for
"`fftw' in `N' dimensions").
As before, we `#include ' and create a plan for the
transforms, this time of type `fftwnd_plan':
fftwnd_plan fftwnd_create_plan(int rank, const int *n,
fftw_direction dir, int flags);
`rank' is the dimensionality of the array, and can be any
nonnegative integer. The next argument, `n', is a pointer to an
integer array of length `rank' containing the (positive) sizes of each
dimension of the array. (Note that the array will be stored in
rowmajor order. *Note Multidimensional Array Format::, for information
on rowmajor order.) The last two parameters are the same as in
`fftw_create_plan'. We now, however, have an additional possible flag,
`FFTW_IN_PLACE', since `fftwnd' supports true inplace transforms.
Multiple flags are combined using a bitwise "or" (`'). (An "inplace"
transform is one in which the output data overwrite the input data. It
thus requires half as much memory asand is often faster thanits
opposite, an "outofplace" transform.)
For two and threedimensional transforms, FFTWND provides
alternative routines that accept the sizes of each dimension directly,
rather than indirectly through a rank and an array of sizes. These are
otherwise identical to `fftwnd_create_plan', and are sometimes more
convenient:
fftwnd_plan fftw2d_create_plan(int nx, int ny,
fftw_direction dir, int flags);
fftwnd_plan fftw3d_create_plan(int nx, int ny, int nz,
fftw_direction dir, int flags);
Once the plan has been created, you can use it any number of times
for transforms of the same size. When you do not need a plan anymore,
you can deallocate the plan by calling `fftwnd_destroy_plan(plan)'.
Given a plan, you can compute the transform of an array of data by
calling:
void fftwnd_one(fftwnd_plan plan, fftw_complex *in, fftw_complex *out);
Here, `in' and `out' point to multidimensional arrays in rowmajor
order, of the size specified when the plan was created. In the case of
an inplace transform, the `out' parameter is ignored and the output
data are stored in the `in' array. The results are stored inorder,
unnormalized, with the zerofrequency component in `out[0]'. A forward
followed by a backward transform (or viceversa) yields the original
data multiplied by the size of the array (i.e. the product of the
dimensions). *Note What FFTWND Really Computes::, for a discussion of
what FFTWND computes.
For example, code to perform an inplace FFT of a threedimensional
array might look like:
#include
...
{
fftw_complex in[L][M][N];
fftwnd_plan p;
...
p = fftw3d_create_plan(L, M, N, FFTW_FORWARD,
FFTW_MEASURE  FFTW_IN_PLACE);
...
fftwnd_one(p, &in[0][0][0], NULL);
...
fftwnd_destroy_plan(p);
}
Note that `in' is a staticallydeclared array, which is
automatically in rowmajor order, but we must take the address of the
first element in order to fit the type expected by `fftwnd_one'.
(*Note Multidimensional Array Format::.)
File: fftw.info, Node: Real Onedimensional Transforms Tutorial, Next: Real Multidimensional Transforms Tutorial, Prev: Complex Multidimensional Transforms Tutorial, Up: Tutorial
Real Onedimensional Transforms Tutorial
========================================
If the input data are purely real, you can save roughly a factor of
two in both time and storage by using the "rfftw" transforms, which are
FFTs specialized for real data. The output of a such a transform is a
"halfcomplex" array, which consists of only half of the complex DFT
amplitudes (since the negativefrequency amplitudes for real data are
the complex conjugate of the positivefrequency amplitudes).
In exchange for these speed and space advantages, the user sacrifices
some of the simplicity of FFTW's complex transforms. First of all, to
allow maximum performance, the output format of the onedimensional real
transforms is different from that used by the multidimensional
transforms. Second, the inverse transform (halfcomplex to real) has the
sideeffect of destroying its input array. Neither of these
inconveniences should pose a serious problem for users, but it is
important to be aware of them. (Both the inconvenient output format
and the sideeffect of the inverse transform can be ameliorated for
onedimensional transforms, at the expense of some performance, by using
instead the multidimensional transform routines with a rank of one.)
The computation of the plan is similar to that for the complex
transforms. First, you `#include '. Then, you create a plan
(of type `rfftw_plan') by calling:
rfftw_plan rfftw_create_plan(int n, fftw_direction dir, int flags);
`n' is the length of the *real* array in the transform (even for
halfcomplextoreal transforms), and can be any positive integer
(although sizes with small factors are transformed more efficiently).
`dir' is either `FFTW_REAL_TO_COMPLEX' or `FFTW_COMPLEX_TO_REAL'. The
`flags' parameter is the same as in `fftw_create_plan'.
Once created, a plan can be used for any number of transforms, and is
deallocated when you are done with it by calling
`rfftw_destroy_plan(plan)'.
Given a plan, a realtocomplex or complextoreal transform is
computed by calling:
void rfftw_one(rfftw_plan plan, fftw_real *in, fftw_real *out);
(Note that `fftw_real' is an alias for the floatingpoint type for
which FFTW was compiled.) Depending upon the direction of the plan,
either the input or the output array is halfcomplex, and is stored in
the following format:
r0, r1, r2, r(n/2), i((n+1)/21), ..., i2, i1
Here, rk is the real part of the kth output, and ik is the imaginary
part. (We follow here the C convention that integer division is
rounded down, e.g. 7 / 2 = 3.) For a halfcomplex array `hc[]', the kth
component has its real part in `hc[k]' and its imaginary part in
`hc[nk]', with the exception of `k' `==' `0' or `n/2' (the latter only
if n is even)in these two cases, the imaginary part is zero due to
symmetries of the realcomplex transform, and is not stored. Thus, the
transform of `n' real values is a halfcomplex array of length `n', and
vice versa. (1) This is actually only half of the DFT spectrum of the
data. Although the other half can be obtained by complex conjugation,
it is not required by many applications such as convolution and
filtering.
Like the complex transforms, the RFFTW transforms are unnormalized,
so a forward followed by a backward transform (or viceversa) yields the
original data scaled by the length of the array, `n'.
Let us reiterate here our warning that an `FFTW_COMPLEX_TO_REAL'
transform has the sideeffect of destroying its (halfcomplex) input.
The `FFTW_REAL_TO_COMPLEX' transform, however, leaves its (real) input
untouched, just as you would hope.
As an example, here is an outline of how you might use RFFTW to
compute the power spectrum of a real array (i.e. the squares of the
absolute values of the DFT amplitudes):
#include
...
{
fftw_real in[N], out[N], power_spectrum[N/2+1];
rfftw_plan p;
int k;
...
p = rfftw_create_plan(N, FFTW_REAL_TO_COMPLEX, FFTW_ESTIMATE);
...
rfftw_one(p, in, out);
power_spectrum[0] = out[0]*out[0]; /* DC component */
for (k = 1; k < (N+1)/2; ++k) /* (k < N/2 rounded up) */
power_spectrum[k] = out[k]*out[k] + out[Nk]*out[Nk];
if (N % 2 == 0) /* N is even */
power_spectrum[N/2] = out[N/2]*out[N/2]; /* Nyquist freq. */
...
rfftw_destroy_plan(p);
}
Programs using RFFTW should link with `lrfftw lfftw lm' on Unix,
or with the FFTW, RFFTW, and math libraries in general.
 Footnotes 
(1) The output for the multidimensional rfftw is a
moreconventional array of `fftw_complex' values, but the format here
permitted us greater efficiency in one dimension.
File: fftw.info, Node: Real Multidimensional Transforms Tutorial, Next: Multidimensional Array Format, Prev: Real Onedimensional Transforms Tutorial, Up: Tutorial
Real Multidimensional Transforms Tutorial
==========================================
FFTW includes multidimensional transforms for real data of any rank.
As with the onedimensional real transforms, they save roughly a factor
of two in time and storage over complex transforms of the same size.
Also as in one dimension, these gains come at the expense of some
increase in complexitythe output format is different from the
onedimensional RFFTW (and is more similar to that of the complex FFTW)
and the inverse (complex to real) transforms have the sideeffect of
overwriting their input data.
To use the real multidimensional transforms, you first `#include
' and then create a plan for the size and direction of
transform that you are interested in:
rfftwnd_plan rfftwnd_create_plan(int rank, const int *n,
fftw_direction dir, int flags);
The first two parameters describe the size of the real data (not the
halfcomplex data, which will have different dimensions). The last two
parameters are the same as those for `rfftw_create_plan'. Just as for
fftwnd, there are two alternate versions of this routine,
`rfftw2d_create_plan' and `rfftw3d_create_plan', that are sometimes
more convenient for two and threedimensional transforms. Also as in
fftwnd, rfftwnd supports true inplace transforms, specified by
including `FFTW_IN_PLACE' in the flags.
Once created, a plan can be used for any number of transforms, and is
deallocated by calling `rfftwnd_destroy_plan(plan)'.
Given a plan, the transform is computed by calling one of the
following two routines:
void rfftwnd_one_real_to_complex(rfftwnd_plan plan,
fftw_real *in, fftw_complex *out);
void rfftwnd_one_complex_to_real(rfftwnd_plan plan,
fftw_complex *in, fftw_real *out);
As is clear from their names and parameter types, the former
function is for `FFTW_REAL_TO_COMPLEX' transforms and the latter is for
`FFTW_COMPLEX_TO_REAL' transforms. (We could have used only a single
routine, since the direction of the transform is encoded in the plan,
but we wanted to correctly express the datatypes of the parameters.)
The latter routine, as we discuss elsewhere, has the sideeffect of
overwriting its input (except when the rank of the array is one). In
both cases, the `out' parameter is ignored for inplace transforms.
The format of the complex arrays deserves careful attention.
Suppose that the real data has dimensions n1 x n2 x ... x nd (in
rowmajor order). Then, after a realtocomplex transform, the output
is an n1 x n2 x ... x (nd/2+1) array of `fftw_complex' values in
rowmajor order, corresponding to slightly over half of the output of
the corresponding complex transform. (Note that the division is
rounded down.) The ordering of the data is otherwise exactly the same
as in the complex case. (In principle, the output could be exactly
half the size of the complex transform output, but in more than one
dimension this requires too complicated a format to be practical.)
Note that, unlike the onedimensional RFFTW, the real and imaginary
parts of the DFT amplitudes are here stored together in the natural way.
Since the complex data is slightly larger than the real data, some
complications arise for inplace transforms. In this case, the final
dimension of the real data must be padded with extra values to
accommodate the size of the complex datatwo 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 * (nd/2+1) `fftw_real' values
(exactly enough to hold the complex data). This physical array size
does not, however, change the *logical* array sizeonly nd values are
actually stored in the last dimension, and nd is the last dimension
passed to `rfftwnd_create_plan'.
For example, consider the transform of a twodimensional real array
of size `nx' by `ny'. The output of the `rfftwnd' transform is a
twodimensional real array of size `nx' by `ny/2+1', where the `y'
dimension has been cut nearly in half because of redundancies in the
output. Because `fftw_complex' is twice the size of `fftw_real', the
output array is slightly bigger than the input array. Thus, if we want
to compute the transform in place, we must *pad* the input array so
that it is of size `nx' by `2*(ny/2+1)'. If `ny' 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).
The RFFTWND transforms are unnormalized, so a forward followed by a
backward transform will result in the original data scaled by the number
of real data elementsthat is, the product of the (logical) dimensions
of the real data.
Below, we illustrate the use of RFFTWND by showing how you might use
it to compute the (cyclic) convolution of twodimensional real arrays
`a' and `b' (using the identity that a convolution corresponds to a
pointwise product of the Fourier transforms). For variety, inplace
transforms are used for the forward FFTs and an outofplace transform
is used for the inverse transform.
#include
...
{
fftw_real a[M][2*(N/2+1)], b[M][2*(N/2+1)], c[M][N];
fftw_complex *A, *B, C[M][N/2+1];
rfftwnd_plan p, pinv;
fftw_real scale = 1.0 / (M * N);
int i, j;
...
p = rfftw2d_create_plan(M, N, FFTW_REAL_TO_COMPLEX,
FFTW_ESTIMATE  FFTW_IN_PLACE);
pinv = rfftw2d_create_plan(M, N, FFTW_COMPLEX_TO_REAL,
FFTW_ESTIMATE);
/* aliases for accessing complex transform outputs: */
A = (fftw_complex*) &a[0][0];
B = (fftw_complex*) &b[0][0];
...
for (i = 0; i < M; ++i)
for (j = 0; j < N; ++j) {
a[i][j] = ... ;
b[i][j] = ... ;
}
...
rfftwnd_one_real_to_complex(p, &a[0][0], NULL);
rfftwnd_one_real_to_complex(p, &b[0][0], NULL);
for (i = 0; i < M; ++i)
for (j = 0; j < N/2+1; ++j) {
int ij = i*(N/2+1) + j;
C[i][j].re = (A[ij].re * B[ij].re
 A[ij].im * B[ij].im) * scale;
C[i][j].im = (A[ij].re * B[ij].im
+ A[ij].im * B[ij].re) * scale;
}
/* inverse transform to get c, the convolution of a and b;
this has the side effect of overwriting C */
rfftwnd_one_complex_to_real(pinv, &C[0][0], &c[0][0]);
...
rfftwnd_destroy_plan(p);
rfftwnd_destroy_plan(pinv);
}
We access the complex outputs of the inplace transforms by casting
each real array to a `fftw_complex' pointer. Because this is a "flat"
pointer, we have to compute the rowmajor index `ij' explicitly in the
convolution product loop. In order to normalize the convolution, we
must multiply by a scale factorwe can do so either before or after
the inverse transform, and choose the former because it obviates the
necessity of an additional loop. Notice the limits of the loops and
the dimensions of the various arrays.
As with the onedimensional RFFTW, an outofplace
`FFTW_COMPLEX_TO_REAL' transform has the sideeffect of overwriting its
input array. (The realtocomplex transform, on the other hand, leaves
its input array untouched.) If you use RFFTWND for a rankone
transform, however, this sideeffect does not occur. Because of this
fact (and the simpler output format), users may find the RFFTWND
interface more convenient than RFFTW for onedimensional transforms.
However, RFFTWND in one dimension is slightly slower than RFFTW because
RFFTWND uses an extra buffer array internally.
File: fftw.info, Node: Multidimensional Array Format, Next: Words of Wisdom, Prev: Real Multidimensional Transforms Tutorial, Up: Tutorial
Multidimensional Array Format
==============================
This section describes the format in which multidimensional arrays
are stored. We felt that a detailed discussion of this topic was
necessary, since it is often a source of confusion among users and
several different formats are common. Although the comments below
refer to `fftwnd', they are also applicable to the `rfftwnd' routines.
* Menu:
* Rowmajor Format::
* Columnmajor Format::
* Static Arrays in C::
* Dynamic Arrays in C::
* Dynamic Arrays in CThe Wrong Way::
File: fftw.info, Node: Rowmajor Format, Next: Columnmajor Format, Prev: Multidimensional Array Format, Up: Multidimensional Array Format
Rowmajor Format

The multidimensional arrays passed to `fftwnd' are expected to be
stored as a single contiguous block in "rowmajor" order (sometimes
called "C order"). Basically, this means that as you step through
adjacent memory locations, the first dimension's index varies most
slowly and the last dimension's index varies most quickly.
To be more explicit, let us consider an array of rank d whose
dimensions are n1 x n2 x n3 x ... x nd. Now, we specify a location in
the array by a sequence of (zerobased) indices, one for each dimension:
(i1, i2, ..., id). If the array is stored in rowmajor order, then
this element is located at the position id + nd * (id1 + nd1 * (... +
n2 * i1)).
Note that each element of the array must be of type `fftw_complex';
i.e. a (real, imaginary) pair of (doubleprecision) numbers. Note also
that, in `fftwnd', the expression above is multiplied by the stride to
get the actual array indexthis is useful in situations where each
element of the multidimensional array is actually a data structure or
another array, and you just want to transform a single field. In most
cases, however, you use a stride of 1.
File: fftw.info, Node: Columnmajor Format, Next: Static Arrays in C, Prev: Rowmajor Format, Up: Multidimensional Array Format
Columnmajor Format

Readers from the Fortran world are used to arrays stored in
"columnmajor" order (sometimes called "Fortran order"). This is
essentially the exact opposite of rowmajor order in that, here, the
*first* dimension's index varies most quickly.
If you have an array stored in columnmajor order and wish to
transform it using `fftwnd', it is quite easy to do. When creating the
plan, simply pass the dimensions of the array to `fftwnd_create_plan' in
*reverse order*. For example, if your array is a rank three `N x M x
L' matrix in columnmajor order, you should pass the dimensions of the
array as if it were an `L x M x N' matrix (which it is, from the
perspective of `fftwnd'). This is done for you automatically by the
FFTW Fortran wrapper routines (*note Calling FFTW from Fortran::.).
File: fftw.info, Node: Static Arrays in C, Next: Dynamic Arrays in C, Prev: Columnmajor Format, Up: Multidimensional Array Format
Static Arrays in C

Multidimensional arrays declared statically (that is, at compile
time, not necessarily with the `static' keyword) in C are *already* in
rowmajor order. You don't have to do anything special to transform
them. (*Note Complex Multidimensional Transforms Tutorial::, for an
example of this sort of code.)
File: fftw.info, Node: Dynamic Arrays in C, Next: Dynamic Arrays in CThe Wrong Way, Prev: Static Arrays in C, Up: Multidimensional Array Format
Dynamic Arrays in C

Often, especially for large arrays, it is desirable to allocate the
arrays dynamically, at runtime. This isn't too hard to do, although it
is not as straightforward for multidimensional arrays as it is for
onedimensional arrays.
Creating the array is simple: using a dynamicallocation routine like
`malloc', allocate an array big enough to store N `fftw_complex'
values, 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 5x12x27 rank 3 array:
fftw_complex *an_array;
an_array = (fftw_complex *) malloc(5 * 12 * 27 * sizeof(fftw_complex));
Accessing the array elements, however, is more trickyyou can't
simply use multiple applications of the `[]' operator like you could for
static arrays. Instead, you have to explicitly compute the offset into
the array using the formula given earlier for rowmajor arrays. For
example, to reference the (i,j,k)th element of the array allocated
above, you would use the expression `an_array[k + 27 * (j + 12 * i)]'.
This pain can be alleviated somewhat by defining appropriate macros,
or, in C++, creating a class and overloading the `()' operator.
File: fftw.info, Node: Dynamic Arrays in CThe Wrong Way, Prev: Dynamic Arrays in C, Up: Multidimensional Array Format
Dynamic Arrays in CThe Wrong Way

A different method for allocating multidimensional arrays in C is
often suggested that is incompatible with `fftwnd': *using it will
cause FFTW to die a painful death*. 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 ...etcetera. For
example, the analogue in this method to the example above is:
int i,j;
fftw_complex ***a_bad_array; /* another way to make a 5x12x27 array */
a_bad_array = (fftw_complex ***) malloc(5 * sizeof(fftw_complex **));
for (i = 0; i < 5; ++i) {
a_bad_array[i] =
(fftw_complex **) malloc(12 * sizeof(fftw_complex *));
for (j = 0; j < 12; ++j)
a_bad_array[i][j] =
(fftw_complex *) malloc(27 * sizeof(fftw_complex));
}
As you can see, this sort of array is inconvenient to allocate (and
deallocate). On the other hand, it has the advantage that the
(i,j,k)th element can be referenced simply by `a_bad_array[i][j][k]'.
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 multidimensional arrays in C,
see the `comp.lang.c' FAQ (http://www.eskimo.com/~scs/Cfaq/s6.html).
File: fftw.info, Node: Words of Wisdom, Prev: Multidimensional Array Format, Up: Tutorial
Words of Wisdom
===============
FFTW implements a method for saving plans to disk and restoring them.
In fact, what FFTW does is more general than just saving and loading
plans. The mechanism is called "`wisdom'". Here, we describe this
feature at a high level. *Note FFTW Reference::, for a less casual (but
more complete) discussion of how to use `wisdom' in FFTW.
Plans created with the `FFTW_MEASURE' option produce nearoptimal
FFT performance, but it can take a long time to compute a plan because
FFTW must actually measure the runtime of many possible plans and select
the best one. This is designed for the situations where so many
transforms of the same size must be computed that the startup time is
irrelevant. For short initialization times but slightly slower
transforms, we have provided `FFTW_ESTIMATE'. The `wisdom' mechanism
is a way to get the best of both worlds. There are, however, certain
caveats that the user must be aware of in using `wisdom'. For this
reason, `wisdom' is an optional feature which is not enabled by default.
At its simplest, `wisdom' provides a way of saving plans to disk so
that they can be reused in other program runs. You create a plan with
the flags `FFTW_MEASURE' and `FFTW_USE_WISDOM', and then save the
`wisdom' using `fftw_export_wisdom':
plan = fftw_create_plan(..., ...  FFTW_MEASURE  FFTW_USE_WISDOM);
fftw_export_wisdom(...);
The next time you run the program, you can restore the `wisdom' with
`fftw_import_wisdom', and then recreate the plan using the same flags
as before. This time, however, the same optimal plan will be created
very quickly without measurements. (FFTW still needs some time to
compute trigonometric tables, however.) The basic outline is:
fftw_import_wisdom(...);
plan = fftw_create_plan(..., ...  FFTW_USE_WISDOM);
Wisdom is more than mere rote memorization, however. FFTW's
`wisdom' encompasses all of the knowledge and measurements that were
used to create the plan for a given size. Therefore, existing `wisdom'
is also applied to the creation of other plans of different sizes.
Whenever a plan is created with the `FFTW_MEASURE' and
`FFTW_USE_WISDOM' flags, `wisdom' is generated. Thereafter, plans for
any transform with a similar factorization will be computed more
quickly, so long as they use the `FFTW_USE_WISDOM' flag. In fact, for
transforms with the same factors and of equal or lesser size, no
measurements at all need to be made and an optimal plan can be created
with negligible delay!
For example, suppose that you create a plan for N = 2^16. Then, for
any equal or smaller power of two, FFTW can create a plan (with the
same direction and flags) quickly, using the precomputed `wisdom'. Even
for larger powers of two, or sizes that are a power of two times some
other prime factors, plans will be computed more quickly than they
would otherwise (although some measurements still have to be made).
The `wisdom' is cumulative, and is stored in a global, private data
structure managed internally by FFTW. The storage space required is
minimal, proportional to the logarithm of the sizes the `wisdom' was
generated from. The `wisdom' can be forgotten (and its associated
memory freed) by a call to `fftw_forget_wisdom()'; otherwise, it is
remembered until the program terminates. It can also be exported to a
file, a string, or any other medium using `fftw_export_wisdom' and
restored during a subsequent execution of the program (or a different
program) using `fftw_import_wisdom' (these functions are described
below).
Because `wisdom' is incorporated into FFTW at a very low level, the
same `wisdom' can be used for onedimensional transforms,
multidimensional transforms, and even the parallel extensions to FFTW.
Just include `FFTW_USE_WISDOM' in the flags for whatever plans you
create (i.e., always plan wisely).
Plans created with the `FFTW_ESTIMATE' plan can use `wisdom', but
cannot generate it; only `FFTW_MEASURE' plans actually produce
`wisdom'. Also, plans can only use `wisdom' generated from plans
created with the same direction and flags. For example, a size `42'
`FFTW_BACKWARD' transform will not use `wisdom' produced by a size `42'
`FFTW_FORWARD' transform. The only exception to this rule is that
`FFTW_ESTIMATE' plans can use `wisdom' from `FFTW_MEASURE' plans.
* Menu:
* Caveats in Using Wisdom:: What you should worry about in using wisdom
* Importing and Exporting Wisdom:: I/O of wisdom to disk and other media
File: fftw.info, Node: Caveats in Using Wisdom, Next: Importing and Exporting Wisdom, Prev: Words of Wisdom, Up: Words of Wisdom
Caveats in Using Wisdom

For in much wisdom is much grief, and he that increaseth knowledge
increaseth sorrow. [Ecclesiastes 1:18]
There are pitfalls to using `wisdom', in that it can negate FFTW'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.
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 suboptimal 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 suboptimal plans.
File: fftw.info, Node: Importing and Exporting Wisdom, Prev: Caveats in Using Wisdom, Up: Words of Wisdom
Importing and Exporting Wisdom

void fftw_export_wisdom_to_file(FILE *output_file);
fftw_status fftw_import_wisdom_from_file(FILE *input_file);
`fftw_export_wisdom_to_file' writes the `wisdom' to `output_file',
which must be a file open for writing. `fftw_import_wisdom_from_file'
reads the `wisdom' from `input_file', which must be a file open for
reading, and returns `FFTW_SUCCESS' if successful and `FFTW_FAILURE'
otherwise. In both cases, the file is left open and must be closed by
the caller. It is perfectly fine if other data lie before or after the
`wisdom' in the file, as long as the file is positioned at the
beginning of the `wisdom' data before import.
char *fftw_export_wisdom_to_string(void);
fftw_status fftw_import_wisdom_from_string(const char *input_string)
`fftw_export_wisdom_to_string' allocates a string, exports the
`wisdom' to it in `NULL'terminated format, and returns a pointer to
the string. If there is an error in allocating or writing the data, it
returns `NULL'. The caller is responsible for deallocating the string
(with `fftw_free') when she is done with it.
`fftw_import_wisdom_from_string' imports the `wisdom' from
`input_string', returning `FFTW_SUCCESS' if successful and
`FFTW_FAILURE' otherwise.
Exporting `wisdom' does not affect the store of `wisdom'. Imported
`wisdom' supplements the current store rather than replacing it (except
when there is conflicting `wisdom', in which case the older `wisdom' is
discarded). The format of the exported `wisdom' is "nerdreadable"
LISPlike ASCII text; we will not document it here except to note that
it is insensitive to white space (interested users can contact us for
more details).
*Note FFTW Reference::, for more information, and for a description
of how you can implement `wisdom' import/export for other media besides
files and strings.
The following is a brief example in which the `wisdom' is read from
a file, a plan is created (possibly generating more `wisdom'), and then
the `wisdom' is exported to a string and printed to `stdout'.
{
fftw_plan plan;
char *wisdom_string;
FILE *input_file;
/* open file to read wisdom from */
input_file = fopen("sample.wisdom", "r");
if (FFTW_FAILURE == fftw_import_wisdom_from_file(input_file))
printf("Error reading wisdom!\n");
fclose(input_file); /* be sure to close the file! */
/* create a plan for N=64, possibly creating and/or using wisdom */
plan = fftw_create_plan(64,FFTW_FORWARD,
FFTW_MEASURE  FFTW_USE_WISDOM);
/* ... do some computations with the plan ... */
/* always destroy plans when you are done */
fftw_destroy_plan(plan);
/* write the wisdom to a string */
wisdom_string = fftw_export_wisdom_to_string();
if (wisdom_string != NULL) {
printf("Accumulated wisdom: %s\n",wisdom_string);
/* Just for fun, destroy and restore the wisdom */
fftw_forget_wisdom(); /* all gone! */
fftw_import_wisdom_from_string(wisdom_string);
/* wisdom is back! */
fftw_free(wisdom_string); /* deallocate it since we're done */
}
}
linuxx86_64/info/fftw.info20000644003427200235140000014053010015476203014356 0ustar jimnamdThis is Info file fftw.info, produced by Makeinfo version 1.68 from the
input file fftw.texi.
This is the FFTW User's manual.
Copyright (C) 19971999 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.
File: fftw.info, Node: FFTW Reference, Next: Parallel FFTW, Prev: Tutorial, Up: Top
FFTW Reference
**************
This chapter provides a complete reference for all sequential (i.e.,
oneprocessor) FFTW functions. We first define the data types upon
which FFTW operates, that is, real, complex, and "halfcomplex" numbers
(*note Data Types::.). Then, in four sections, we explain the FFTW
program interface for complex onedimensional transforms (*note
Onedimensional Transforms Reference::.), complex multidimensional
transforms (*note Multidimensional Transforms Reference::.), and real
onedimensional transforms (*note Real Onedimensional Transforms
Reference::.), real multidimensional transforms (*note Real
Multidimensional Transforms Reference::.). *Note Wisdom Reference::
describes the `wisdom' mechanism for exporting and importing plans.
Finally, *Note Memory Allocator Reference:: describes how to change
FFTW's default memory allocator. For parallel transforms, *Note
Parallel FFTW::.
* Menu:
* Data Types:: real, complex, and halfcomplex numbers
* Onedimensional Transforms Reference::
* Multidimensional Transforms Reference::
* Real Onedimensional Transforms Reference::
* Real Multidimensional Transforms Reference::
* Wisdom Reference::
* Memory Allocator Reference::
* Thread safety::
File: fftw.info, Node: Data Types, Next: Onedimensional Transforms Reference, Prev: FFTW Reference, Up: FFTW Reference
Data Types
==========
The routines in the FFTW package use three main kinds of data types.
"Real" and "complex" numbers should be already known to the reader. We
also use the term "halfcomplex" to describe complex arrays in a special
packed format used by the onedimensional real transforms (taking
advantage of the "hermitian" symmetry that arises in those cases).
By including `' or `', you will have access to the
following definitions:
typedef double fftw_real;
typedef struct {
fftw_real re, im;
} fftw_complex;
#define c_re(c) ((c).re)
#define c_im(c) ((c).im)
All FFTW operations are performed on the `fftw_real' and
`fftw_complex' data types. For `fftw_complex' numbers, the two macros
`c_re' and `c_im' retrieve, respectively, the real and imaginary parts
of the number.
A "real array" is an array of real numbers. A "complex array" is an
array of complex numbers. A onedimensional array X of n complex
numbers is "hermitian" if the following property holds: for all 0 <= i
< n, we have X[i] = conj(X[ni]). Hermitian arrays are relevant to
FFTW because the Fourier transform of a real array is hermitian.
Because of its symmetry, a hermitian array can be stored in half the
space of a complex array of the same size. FFTW's onedimensional real
transforms store hermitian arrays as "halfcomplex" arrays. A
halfcomplex array of size n is a onedimensional array of n `fftw_real'
numbers. A hermitian array X in stored into a halfcomplex array Y as
follows. For all integers i such that 0 <= i <= n / 2, we have Y[i] =
Re(X[i]). For all integers i such that 0 < i < n / 2, we have Y[ni] =
Im(X[i]).
We now illustrate halfcomplex storage for n = 4 and n = 5, since the
scheme depends on the parity of n. Let n = 4. In this case, we have
Y[0] = Re(X[0]), Y[1] = Re(X[1]), Y[2] = Re(X[2]), and Y[3] = Im(X[1]).
Let now n = 5. In this case, we have Y[0] = Re(X[0]), Y[1] = Re(X[1]),
Y[2] = Re(X[2]), Y[3] = Im(X[2]), and Y[4] = Im(X[1]).
By default, the type `fftw_real' equals the C type `double'. To
work in single precision rather than double precision, `#define' the
symbol `FFTW_ENABLE_FLOAT' in `fftw.h' and then recompile the library.
On Unix systems, you can instead use `configure enablefloat' at
installation time (*note Installation and Customization::.).
In version 1 of FFTW, the data types were called `FFTW_REAL' and
`FFTW_COMPLEX'. We changed the capitalization for consistency with the
rest of FFTW's conventions. The old names are still supported, but
their use is deprecated.
File: fftw.info, Node: Onedimensional Transforms Reference, Next: Multidimensional Transforms Reference, Prev: Data Types, Up: FFTW Reference
Onedimensional Transforms Reference
====================================
The onedimensional complex routines are generally prefixed with
`fftw_'. Programs using FFTW should be linked with `lfftw lm' on
Unix systems, or with the FFTW and standard math libraries in general.
* Menu:
* fftw_create_plan:: Plan Creation
* Discussion on Specific Plans::
* fftw:: Plan Execution
* fftw_destroy_plan:: Plan Destruction
* What FFTW Really Computes:: Definition of the DFT.
File: fftw.info, Node: fftw_create_plan, Next: Discussion on Specific Plans, Prev: Onedimensional Transforms Reference, Up: Onedimensional Transforms Reference
Plan Creation for Onedimensional Transforms

#include
fftw_plan fftw_create_plan(int n, fftw_direction dir,
int flags);
fftw_plan fftw_create_plan_specific(int n, fftw_direction dir,
int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
The function `fftw_create_plan' creates a plan, which is a data
structure containing all the information that `fftw' needs in order to
compute the 1D Fourier transform. You can create as many plans as you
need, but only one plan for a given array size is required (a plan can
be reused many times).
`fftw_create_plan' returns a valid plan, or `NULL' if, for some
reason, the plan can't be created. In the default installation, this
cannot happen, but it is possible to configure FFTW in such a way that
some input sizes are forbidden, and FFTW cannot create a plan.
The `fftw_create_plan_specific' variant takes as additional
arguments specific input/output arrays and their strides. For the last
four arguments, you should pass the arrays and strides that you will
eventually be passing to `fftw'. The resulting plans will be optimized
for those arrays and strides, although they may be used on other arrays
as well. Note: the contents of the in and out arrays are *destroyed*
by the specific planner (the initial contents are ignored, so the
arrays need not have been initialized).
Arguments
.........
* `n' is the size of the transform. It can be any positive integer.
 FFTW is best at handling sizes of the form 2^a 3^b 5^c 7^d
11^e 13^f, where e+f is either 0 or 1, and the other
exponents are arbitrary. Other sizes are computed by means
of a slow, generalpurpose routine (which nevertheless retains
O(n lg n) performance, even for prime sizes). (It is
possible to customize FFTW for different array sizes. *Note
Installation and Customization::, for more information.)
Transforms whose sizes are powers of 2 are especially fast.
* `dir' is the sign of the exponent in the formula that defines the
Fourier transform. It can be 1 or +1. The aliases
`FFTW_FORWARD' and `FFTW_BACKWARD' are provided, where
`FFTW_FORWARD' stands for 1.
* `flags' is a boolean OR (`') of zero or more of the following:
 `FFTW_MEASURE': this flag tells FFTW to find the optimal plan
by actually *computing* several FFTs and measuring their
execution time. Depending on the installation, this can take
some time. (1)
 `FFTW_ESTIMATE': do not run any FFT and provide a "reasonable"
plan (for a RISC processor with many registers). If neither
`FFTW_ESTIMATE' nor `FFTW_MEASURE' is provided, the default is
`FFTW_ESTIMATE'.
 `FFTW_OUT_OF_PLACE': produce a plan assuming that the input
and output arrays will be distinct (this is the default).
 `FFTW_IN_PLACE': produce a plan assuming that you want the
output in the input array. The algorithm used is not
necessarily in place: FFTW is able to compute true inplace
transforms only for small values of `n'. If FFTW is not able
to compute the transform inplace, it will allocate a
temporary array (unless you provide one yourself), compute
the transform out of place, and copy the result back.
*Warning: This option changes the meaning of some parameters
of `fftw'* (*note Computing the Onedimensional Transform:
fftw.).
The inplace option is mainly provided for people who want to
write their own inplace multidimensional Fourier transform,
using FFTW as a base. For example, consider a
threedimensional `n * n * n' transform. An outofplace
algorithm will need another array (which may be huge).
However, FFTW can compute the inplace transform along each
dimension using only a temporary array of size `n'.
Moreover, if FFTW happens to be able to compute the transform
truly inplace, no temporary array and no copying are needed.
As distributed, FFTW `knows' how to compute inplace
transforms of size 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 32 and 64.
The default mode of operation is `FFTW_OUT_OF_PLACE'.
 `FFTW_USE_WISDOM': use any `wisdom' that is available to help
in the creation of the plan. (*Note Words of Wisdom::.) This
can greatly speed the creation of plans, especially with the
`FFTW_MEASURE' option. `FFTW_ESTIMATE' plans can also take
advantage of `wisdom' to produce a more optimal plan (based
on past measurements) than the estimation heuristic would
normally generate. When the `FFTW_MEASURE' option is used,
new `wisdom' will also be generated if the current transform
size is not completely understood by existing `wisdom'.
* `in', `out', `istride', `ostride' (only for
`fftw_create_plan_specific'): see corresponding arguments in the
description of `fftw'. (*Note Computing the Onedimensional
Transform: fftw.) In particular, the `out' and `ostride'
parameters have the same special meaning for `FFTW_IN_PLACE'
transforms as they have for `fftw'.
 Footnotes 
(1) The basic problem is the resolution of the clock: FFTW needs to
run for a certain time for the clock to be reliable.
File: fftw.info, Node: Discussion on Specific Plans, Next: fftw, Prev: fftw_create_plan, Up: Onedimensional Transforms Reference
Discussion on Specific Plans

We recommend the use of the specific planners, even in cases where
you will be transforming arrays different from those passed to the
specific planners, as they confer the following advantages:
* The resulting plans will be optimized for your specific arrays and
strides. This may or may not make a significant difference, but it
certainly doesn't hurt. (The ordinary planner does its planning
based upon a strideone temporary array that it allocates.)
* Less intermediate storage is required during the planning process.
(The ordinary planner uses O(`N') temporary storage, where `N' is
the maximum dimension, while it is creating the plan.)
* For multidimensional transforms, new parameters become accessible
for optimization by the planner. (Since multidimensional arrays
can be very large, we don't dare to allocate one in the ordinary
planner for experimentation. This prevents us from doing certain
optimizations that can yield dramatic improvements in some cases.)
On the other hand, note that *the specific planner destroys the
contents of the `in' and `out' arrays*.
File: fftw.info, Node: fftw, Next: fftw_destroy_plan, Prev: Discussion on Specific Plans, Up: Onedimensional Transforms Reference
Computing the Onedimensional Transform

#include
void fftw(fftw_plan plan, int howmany,
fftw_complex *in, int istride, int idist,
fftw_complex *out, int ostride, int odist);
void fftw_one(fftw_plan plan, fftw_complex *in,
fftw_complex *out);
The function `fftw' computes the onedimensional Fourier transform,
using a plan created by `fftw_create_plan' (*Note Plan Creation for
Onedimensional Transforms: fftw_create_plan.) The function `fftw_one'
provides a simplified interface for the common case of single input
array of stride 1.
Arguments
.........
* `plan' is the plan created by `fftw_create_plan' (*note Plan
Creation for Onedimensional Transforms: fftw_create_plan.).
* `howmany' is the number of transforms `fftw' will compute. It is
faster to tell FFTW to compute many transforms, instead of simply
calling `fftw' many times.
* `in', `istride' and `idist' describe the input array(s). There
are `howmany' input arrays; the first one is pointed to by `in',
the second one is pointed to by `in + idist', and so on, up to `in
+ (howmany  1) * idist'. Each input array consists of complex
numbers (*note Data Types::.), which are not necessarily
contiguous in memory. Specifically, `in[0]' is the first element
of the first array, `in[istride]' is the second element of the
first array, and so on. In general, the `i'th element of the
`j'th input array will be in position `in[i * istride + j *
idist]'.
* `out', `ostride' and `odist' describe the output array(s). The
format is the same as for the input array.
 *Inplace transforms*: If the `plan' specifies an inplace
transform, `ostride' and `odist' are always ignored. If
`out' is `NULL', `out' is ignored, too. Otherwise, `out' is
interpreted as a pointer to an array of `n' complex numbers,
that FFTW will use as temporary space to perform the inplace
computation. `out' is used as scratch space and its contents
destroyed. In this case, `out' must be an ordinary array
whose elements are contiguous in memory (no striding).
The function `fftw_one' transforms a single, contiguous input array
to a contiguous output array. By definition, the call
fftw_one(plan, in, out)
is equivalent to
fftw(plan, 1, in, 1, 1, out, 1, 1)
File: fftw.info, Node: fftw_destroy_plan, Next: What FFTW Really Computes, Prev: fftw, Up: Onedimensional Transforms Reference
Destroying a Onedimensional Plan

#include
void fftw_destroy_plan(fftw_plan plan);
The function `fftw_destroy_plan' frees the plan `plan' and releases
all the memory associated with it. After destruction, a plan is no
longer valid.
File: fftw.info, Node: What FFTW Really Computes, Prev: fftw_destroy_plan, Up: Onedimensional Transforms Reference
What FFTW Really Computes

In this section, we define precisely what FFTW computes. Please be
warned that different authors and software packages might employ
different conventions than FFTW does.
The forward transform of a complex array X of size n computes an
array Y, where
Y[i] = sum for j = 0 to (n  1) of X[j] * exp(2 pi i j sqrt(1)/n) .
The backward transform computes
Y[i] = sum for j = 0 to (n  1) of X[j] * exp(2 pi i j sqrt(1)/n) .
FFTW computes an unnormalized transform, that is, the equation
IFFT(FFT(X)) = n X holds. In other words, applying the forward and
then the backward transform will multiply the input by n.
An `FFTW_FORWARD' transform corresponds to a sign of 1 in the
exponent of the DFT. Note also that we use the standard "inorder"
output orderingthe kth output corresponds to the frequency k/n (or
k/T, where T 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 k/n is the same as the frequency
(nk)/n.)
File: fftw.info, Node: Multidimensional Transforms Reference, Next: Real Onedimensional Transforms Reference, Prev: Onedimensional Transforms Reference, Up: FFTW Reference
Multidimensional Transforms Reference
======================================
The multidimensional complex routines are generally prefixed with
`fftwnd_'. Programs using FFTWND should be linked with `lfftw lm' on
Unix systems, or with the FFTW and standard math libraries in general.
* Menu:
* fftwnd_create_plan:: Plan Creation
* fftwnd:: Plan Execution
* fftwnd_destroy_plan:: Plan Destruction
* What FFTWND Really Computes::
File: fftw.info, Node: fftwnd_create_plan, Next: fftwnd, Prev: Multidimensional Transforms Reference, Up: Multidimensional Transforms Reference
Plan Creation for Multidimensional Transforms

#include
fftwnd_plan fftwnd_create_plan(int rank, const int *n,
fftw_direction dir, int flags);
fftwnd_plan fftw2d_create_plan(int nx, int ny,
fftw_direction dir, int flags);
fftwnd_plan fftw3d_create_plan(int nx, int ny, int nz,
fftw_direction dir, int flags);
fftwnd_plan fftwnd_create_plan_specific(int rank, const int *n,
fftw_direction dir,
int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
fftwnd_plan fftw2d_create_plan_specific(int nx, int ny,
fftw_direction dir,
int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
fftwnd_plan fftw3d_create_plan_specific(int nx, int ny, int nz,
fftw_direction dir, int flags,
fftw_complex *in, int istride,
fftw_complex *out, int ostride);
The function `fftwnd_create_plan' creates a plan, which is a data
structure containing all the information that `fftwnd' needs in order
to compute a multidimensional Fourier transform. You can create as
many plans as you need, but only one plan for a given array size is
required (a plan can be reused many times). The functions
`fftw2d_create_plan' and `fftw3d_create_plan' are optional, alternative
interfaces to `fftwnd_create_plan' for two and three dimensions,
respectively.
`fftwnd_create_plan' returns a valid plan, or `NULL' if, for some
reason, the plan can't be created. This can happen if memory runs out
or if the arguments are invalid in some way (e.g. if `rank' < 0).
The `create_plan_specific' variants take as additional arguments
specific input/output arrays and their strides. For the last four
arguments, you should pass the arrays and strides that you will
eventually be passing to `fftwnd'. The resulting plans will be
optimized for those arrays and strides, although they may be used on
other arrays as well. Note: the contents of the in and out arrays are
*destroyed* by the specific planner (the initial contents are ignored,
so the arrays need not have been initialized). *Note Discussion on
Specific Plans::, for a discussion on specific plans.
Arguments
.........
* `rank' is the dimensionality of the arrays to be transformed. It
can be any nonnegative integer.
* `n' is a pointer to an array of `rank' integers, giving the size
of each dimension of the arrays to be transformed. These sizes,
which must be positive integers, correspond to the dimensions of
rowmajor arraysi.e. `n[0]' is the size of the dimension whose
indices vary most slowly, and so on. (*Note Multidimensional
Array Format::, for more information on rowmajor storage.) *Note
Plan Creation for Onedimensional Transforms: fftw_create_plan,
for more information regarding optimal array sizes.
* `nx' and `ny' in `fftw2d_create_plan' are positive integers
specifying the dimensions of the rank 2 array to be transformed.
i.e. they specify that the transform will operate on `nx x ny'
arrays in rowmajor order, where `nx' is the number of rows and
`ny' is the number of columns.
* `nx', `ny' and `nz' in `fftw3d_create_plan' are positive integers
specifying the dimensions of the rank 3 array to be transformed.
i.e. they specify that the transform will operate on `nx x ny x
nz' arrays in rowmajor order.
* `dir' is the sign of the exponent in the formula that defines the
Fourier transform. It can be 1 or +1. The aliases
`FFTW_FORWARD' and `FFTW_BACKWARD' are provided, where
`FFTW_FORWARD' stands for 1.
* `flags' is a boolean OR (`') of zero or more of the following:
 `FFTW_MEASURE': this flag tells FFTW to find the optimal plan
by actually *computing* several FFTs and measuring their
execution time.
 `FFTW_ESTIMATE': do not run any FFT and provide a "reasonable"
plan (for a RISC processor with many registers). If neither
`FFTW_ESTIMATE' nor `FFTW_MEASURE' is provided, the default is
`FFTW_ESTIMATE'.
 `FFTW_OUT_OF_PLACE': produce a plan assuming that the input
and output arrays will be distinct (this is the default).
 `FFTW_IN_PLACE': produce a plan assuming that you want to
perform the transform inplace. (Unlike the onedimensional
transform, this "really" (1) performs the transform
inplace.) Note that, if you want to perform inplace
transforms, you *must* use a plan created with this option.
The default mode of operation is `FFTW_OUT_OF_PLACE'.
 `FFTW_USE_WISDOM': use any `wisdom' that is available to help
in the creation of the plan. (*Note Words of Wisdom::.) This
can greatly speed the creation of plans, especially with the
`FFTW_MEASURE' option. `FFTW_ESTIMATE' plans can also take
advantage of `wisdom' to produce a more optimal plan (based
on past measurements) than the estimation heuristic would
normally generate. When the `FFTW_MEASURE' option is used,
new `wisdom' will also be generated if the current transform
size is not completely understood by existing `wisdom'. Note
that the same `wisdom' is shared between onedimensional and
multidimensional transforms.
* `in', `out', `istride', `ostride' (only for the
`_create_plan_specific' variants): see corresponding arguments in
the description of `fftwnd'. (*Note Computing the
Multidimensional Transform: fftwnd.)
 Footnotes 
(1) `fftwnd' actually may use some temporary storage (hidden in the
plan), but this storage space is only the size of the largest dimension
of the array, rather than being as big as the entire array. (Unless
you use `fftwnd' to perform onedimensional transforms, in which case
the temporary storage required for inplace transforms *is* as big as
the entire array.)
File: fftw.info, Node: fftwnd, Next: fftwnd_destroy_plan, Prev: fftwnd_create_plan, Up: Multidimensional Transforms Reference
Computing the Multidimensional Transform

#include
void fftwnd(fftwnd_plan plan, int howmany,
fftw_complex *in, int istride, int idist,
fftw_complex *out, int ostride, int odist);
void fftwnd_one(fftwnd_plan p, fftw_complex *in,
fftw_complex *out);
The function `fftwnd' computes one or more multidimensional Fourier
Transforms, using a plan created by `fftwnd_create_plan' (*note Plan
Creation for Multidimensional Transforms: fftwnd_create_plan.). (Note
that the plan determines the rank and dimensions of the array to be
transformed.) The function `fftwnd_one' provides a simplified
interface for the common case of single input array of stride 1.
Arguments
.........
* `plan' is the plan created by `fftwnd_create_plan'. (*note Plan
Creation for Multidimensional Transforms: fftwnd_create_plan.).
In the case of two and threedimensional transforms, it could also
have been created by `fftw2d_create_plan' or `fftw3d_create_plan',
respectively.
* `howmany' is the number of multidimensional transforms `fftwnd'
will compute.
* `in', `istride' and `idist' describe the input array(s). There
are `howmany' multidimensional input arrays; the first one is
pointed to by `in', the second one is pointed to by `in + idist',
and so on, up to `in + (howmany  1) * idist'. Each
multidimensional input array consists of complex numbers (*note
Data Types::.), stored in rowmajor format (*note
Multidimensional Array Format::.), which are not necessarily
contiguous in memory. Specifically, `in[0]' is the first element
of the first array, `in[istride]' is the second element of the
first array, and so on. In general, the `i'th element of the
`j'th input array will be in position `in[i * istride + j *
idist]'. Note that, here, `i' refers to an index into the
rowmajor format for the multidimensional array, rather than an
index in any particular dimension.
 *Inplace transforms*: For plans created with the
`FFTW_IN_PLACE' option, the transform is computed
inplacethe output is returned in the `in' array, using the
same strides, etcetera, as were used in the input.
* `out', `ostride' and `odist' describe the output array(s). The
format is the same as for the input array.
 *Inplace transforms*: These parameters are ignored for plans
created with the `FFTW_IN_PLACE' option.
The function `fftwnd_one' transforms a single, contiguous input
array to a contiguous output array. By definition, the call
fftwnd_one(plan, in, out)
is equivalent to
fftwnd(plan, 1, in, 1, 1, out, 1, 1)
File: fftw.info, Node: fftwnd_destroy_plan, Next: What FFTWND Really Computes, Prev: fftwnd, Up: Multidimensional Transforms Reference
Destroying a Multidimensional Plan

#include
void fftwnd_destroy_plan(fftwnd_plan plan);
The function `fftwnd_destroy_plan' frees the plan `plan' and
releases all the memory associated with it. After destruction, a plan
is no longer valid.
File: fftw.info, Node: What FFTWND Really Computes, Prev: fftwnd_destroy_plan, Up: Multidimensional Transforms Reference
What FFTWND Really Computes

The conventions that we follow for the multidimensional transform
are analogous to those for the onedimensional transform. In
particular, the forward transform has a negative sign in the exponent
and neither the forward nor the backward transforms will perform any
normalization. Computing the backward transform of the forward
transform will multiply the array by the product of its dimensions.
The output is inorder, and the zeroth element of the output is the
amplitude of the zero frequency component.
The TeX version of this manual contains the exact definition of the
ndimensional transform FFTW uses. It is not possible to display the
definition on a ASCII terminal properly.
File: fftw.info, Node: Real Onedimensional Transforms Reference, Next: Real Multidimensional Transforms Reference, Prev: Multidimensional Transforms Reference, Up: FFTW Reference
Real Onedimensional Transforms Reference
=========================================
The onedimensional real routines are generally prefixed with
`rfftw_'. (1) Programs using RFFTW should be linked with `lrfftw
lfftw lm' on Unix systems, or with the RFFTW, the FFTW, and the
standard math libraries in general.
* Menu:
* rfftw_create_plan:: Plan Creation
* rfftw:: Plan Execution
* rfftw_destroy_plan:: Plan Destruction
* What RFFTW Really Computes::
 Footnotes 
(1) The etymologicallycorrect spelling would be `frftw_', but it is
hard to remember.
File: fftw.info, Node: rfftw_create_plan, Next: rfftw, Prev: Real Onedimensional Transforms Reference, Up: Real Onedimensional Transforms Reference
Plan Creation for Real Onedimensional Transforms

#include
rfftw_plan rfftw_create_plan(int n, fftw_direction dir, int flags);
rfftw_plan rfftw_create_plan_specific(int n, fftw_direction dir,
int flags, fftw_real *in, int istride,
fftw_real *out, int ostride);
The function `rfftw_create_plan' creates a plan, which is a data
structure containing all the information that `rfftw' needs in order to
compute the 1D real Fourier transform. You can create as many plans as
you need, but only one plan for a given array size is required (a plan
can be reused many times).
`rfftw_create_plan' returns a valid plan, or `NULL' if, for some
reason, the plan can't be created. In the default installation, this
cannot happen, but it is possible to configure RFFTW in such a way that
some input sizes are forbidden, and RFFTW cannot create a plan.
The `rfftw_create_plan_specific' variant takes as additional
arguments specific input/output arrays and their strides. For the last
four arguments, you should pass the arrays and strides that you will
eventually be passing to `rfftw'. The resulting plans will be
optimized for those arrays and strides, although they may be used on
other arrays as well. Note: the contents of the in and out arrays are
*destroyed* by the specific planner (the initial contents are ignored,
so the arrays need not have been initialized). *Note Discussion on
Specific Plans::, for a discussion on specific plans.
Arguments
.........
* `n' is the size of the transform. It can be any positive integer.
 RFFTW is best at handling sizes of the form 2^a 3^b 5^c 7^d
11^e 13^f, where e+f is either 0 or 1, and the other
exponents are arbitrary. Other sizes are computed by means
of a slow, generalpurpose routine (reducing to O(n^2)
performance for prime sizes). (It is possible to customize
RFFTW for different array sizes. *Note Installation and
Customization::, for more information.) Transforms whose
sizes are powers of 2 are especially fast.
* `dir' is the direction of the desired transform, either
`FFTW_REAL_TO_COMPLEX' or `FFTW_COMPLEX_TO_REAL', corresponding to
`FFTW_FORWARD' or `FFTW_BACKWARD', respectively.
* `flags' is a boolean OR (`') of zero or more of the following:
 `FFTW_MEASURE': this flag tells RFFTW to find the optimal
plan by actually *computing* several FFTs and measuring their
execution time. Depending on the installation, this can take
some time.
 `FFTW_ESTIMATE': do not run any FFT and provide a "reasonable"
plan (for a RISC processor with many registers). If neither
`FFTW_ESTIMATE' nor `FFTW_MEASURE' is provided, the default is
`FFTW_ESTIMATE'.
 `FFTW_OUT_OF_PLACE': produce a plan assuming that the input
and output arrays will be distinct (this is the default).
 `FFTW_IN_PLACE': produce a plan assuming that you want the
output in the input array. The algorithm used is not
necessarily in place: RFFTW is able to compute true inplace
transforms only for small values of `n'. If RFFTW is not
able to compute the transform inplace, it will allocate a
temporary array (unless you provide one yourself), compute
the transform out of place, and copy the result back.
*Warning: This option changes the meaning of some parameters
of `rfftw'* (*note Computing the Real Onedimensional
Transform: rfftw.).
The default mode of operation is `FFTW_OUT_OF_PLACE'.
 `FFTW_USE_WISDOM': use any `wisdom' that is available to help
in the creation of the plan. (*Note Words of Wisdom::.) This
can greatly speed the creation of plans, especially with the
`FFTW_MEASURE' option. `FFTW_ESTIMATE' plans can also take
advantage of `wisdom' to produce a more optimal plan (based
on past measurements) than the estimation heuristic would
normally generate. When the `FFTW_MEASURE' option is used,
new `wisdom' will also be generated if the current transform
size is not completely understood by existing `wisdom'.
* `in', `out', `istride', `ostride' (only for
`rfftw_create_plan_specific'): see corresponding arguments in the
description of `rfftw'. (*Note Computing the Real Onedimensional
Transform: rfftw.) In particular, the `out' and `ostride'
parameters have the same special meaning for `FFTW_IN_PLACE'
transforms as they have for `rfftw'.
File: fftw.info, Node: rfftw, Next: rfftw_destroy_plan, Prev: rfftw_create_plan, Up: Real Onedimensional Transforms Reference
Computing the Real Onedimensional Transform

#include
void rfftw(rfftw_plan plan, int howmany,
fftw_real *in, int istride, int idist,
fftw_real *out, int ostride, int odist);
void rfftw_one(rfftw_plan plan, fftw_real *in, fftw_real *out);
The function `rfftw' computes the Real Onedimensional Fourier
Transform, using a plan created by `rfftw_create_plan' (*note Plan
Creation for Real Onedimensional Transforms: rfftw_create_plan.). The
function `rfftw_one' provides a simplified interface for the common
case of single input array of stride 1.
*Important:* When invoked for an outofplace,
`FFTW_COMPLEX_TO_REAL' transform, the input array is overwritten with
scratch values by these routines. The input array is not modified for
`FFTW_REAL_TO_COMPLEX' transforms.
Arguments
.........
* `plan' is the plan created by `rfftw_create_plan' (*note Plan
Creation for Real Onedimensional Transforms: rfftw_create_plan.).
* `howmany' is the number of transforms `rfftw' will compute. It is
faster to tell RFFTW to compute many transforms, instead of simply
calling `rfftw' many times.
* `in', `istride' and `idist' describe the input array(s). There
are two cases. If the `plan' defines a `FFTW_REAL_TO_COMPLEX'
transform, `in' is a real array. Otherwise, for
`FFTW_COMPLEX_TO_REAL' transforms, `in' is a halfcomplex array
*whose contents will be destroyed*.
* `out', `ostride' and `odist' describe the output array(s), and
have the same meaning as the corresponding parameters for the
input array.
 *Inplace transforms*: If the `plan' specifies an inplace
transform, `ostride' and `odist' are always ignored. If
`out' is `NULL', `out' is ignored, too. Otherwise, `out' is
interpreted as a pointer to an array of `n' complex numbers,
that FFTW will use as temporary space to perform the inplace
computation. `out' is used as scratch space and its contents
destroyed. In this case, `out' must be an ordinary array
whose elements are contiguous in memory (no striding).
The function `rfftw_one' transforms a single, contiguous input array
to a contiguous output array. By definition, the call
rfftw_one(plan, in, out)
is equivalent to
rfftw(plan, 1, in, 1, 1, out, 1, 1)
File: fftw.info, Node: rfftw_destroy_plan, Next: What RFFTW Really Computes, Prev: rfftw, Up: Real Onedimensional Transforms Reference
Destroying a Real Onedimensional Plan

#include
void rfftw_destroy_plan(rfftw_plan plan);
The function `rfftw_destroy_plan' frees the plan `plan' and releases
all the memory associated with it. After destruction, a plan is no
longer valid.
File: fftw.info, Node: What RFFTW Really Computes, Prev: rfftw_destroy_plan, Up: Real Onedimensional Transforms Reference
What RFFTW Really Computes

In this section, we define precisely what RFFTW computes.
The real to complex (`FFTW_REAL_TO_COMPLEX') transform of a real
array X of size n computes an hermitian array Y, where
Y[i] = sum for j = 0 to (n  1) of X[j] * exp(2 pi i j sqrt(1)/n)
(That Y is a hermitian array is not intended to be obvious, although
the proof is easy.) The hermitian array Y is stored in halfcomplex
order (*note Data Types::.). Currently, RFFTW provides no way to
compute a real to complex transform with a positive sign in the
exponent.
The complex to real (`FFTW_COMPLEX_TO_REAL') transform of a hermitian
array X of size n computes a real array Y, where
Y[i] = sum for j = 0 to (n  1) of X[j] * exp(2 pi i j sqrt(1)/n)
(That Y is a real array is not intended to be obvious, although the
proof is easy.) The hermitian input array X is stored in halfcomplex
order (*note Data Types::.). Currently, RFFTW provides no way to
compute a complex to real transform with a negative sign in the
exponent.
Like FFTW, RFFTW computes an unnormalized transform. In other words,
applying the real to complex (forward) and then the complex to real
(backward) transform will multiply the input by n.
File: fftw.info, Node: Real Multidimensional Transforms Reference, Next: Wisdom Reference, Prev: Real Onedimensional Transforms Reference, Up: FFTW Reference
Real Multidimensional Transforms Reference
===========================================
The multidimensional real routines are generally prefixed with
`rfftwnd_'. Programs using RFFTWND should be linked with `lrfftw
lfftw lm' on Unix systems, or with the FFTW, RFFTW, and standard math
libraries in general.
* Menu:
* rfftwnd_create_plan:: Plan Creation
* rfftwnd:: Plan Execution
* Array Dimensions for Real Multidimensional Transforms::
* Strides in Inplace RFFTWND::
* rfftwnd_destroy_plan:: Plan Destruction
* What RFFTWND Really Computes::
File: fftw.info, Node: rfftwnd_create_plan, Next: rfftwnd, Prev: Real Multidimensional Transforms Reference, Up: Real Multidimensional Transforms Reference
Plan Creation for Real Multidimensional Transforms

#include
rfftwnd_plan rfftwnd_create_plan(int rank, const int *n,
fftw_direction dir, int flags);
rfftwnd_plan rfftw2d_create_plan(int nx, int ny,
fftw_direction dir, int flags);
rfftwnd_plan rfftw3d_create_plan(int nx, int ny, int nz,
fftw_direction dir, int flags);
The function `rfftwnd_create_plan' creates a plan, which is a data
structure containing all the information that `rfftwnd' needs in order
to compute a multidimensional real Fourier transform. You can create
as many plans as you need, but only one plan for a given array size is
required (a plan can be reused many times). The functions
`rfftw2d_create_plan' and `rfftw3d_create_plan' are optional,
alternative interfaces to `rfftwnd_create_plan' for two and three
dimensions, respectively.
`rfftwnd_create_plan' returns a valid plan, or `NULL' if, for some
reason, the plan can't be created. This can happen if the arguments
are invalid in some way (e.g. if `rank' < 0).
Arguments
.........
* `rank' is the dimensionality of the arrays to be transformed. It
can be any nonnegative integer.
* `n' is a pointer to an array of `rank' integers, giving the size
of each dimension of the arrays to be transformed. Note that these
are always the dimensions of the *real* arrays; the complex arrays
have different dimensions (*note Array Dimensions for Real
Multidimensional Transforms::.). These sizes, which must be
positive integers, correspond to the dimensions of rowmajor
arraysi.e. `n[0]' is the size of the dimension whose indices
vary most slowly, and so on. (*Note Multidimensional Array
Format::, for more information.)
 *Note Plan Creation for Real Onedimensional Transforms:
rfftw_create_plan, for more information regarding optimal
array sizes.
* `nx' and `ny' in `rfftw2d_create_plan' are positive integers
specifying the dimensions of the rank 2 array to be transformed.
i.e. they specify that the transform will operate on `nx x ny'
arrays in rowmajor order, where `nx' is the number of rows and
`ny' is the number of columns.
* `nx', `ny' and `nz' in `rfftw3d_create_plan' are positive integers
specifying the dimensions of the rank 3 array to be transformed.
i.e. they specify that the transform will operate on `nx x ny x
nz' arrays in rowmajor order.
* `dir' is the direction of the desired transform, either
`FFTW_REAL_TO_COMPLEX' or `FFTW_COMPLEX_TO_REAL', corresponding to
`FFTW_FORWARD' or `FFTW_BACKWARD', respectively.
* `flags' is a boolean OR (`') of zero or more of the following:
 `FFTW_MEASURE': this flag tells FFTW to find the optimal plan
by actually *computing* several FFTs and measuring their
execution time.
 `FFTW_ESTIMATE': do not run any FFT and provide a "reasonable"
plan (for a RISC processor with many registers). If neither
`FFTW_ESTIMATE' nor `FFTW_MEASURE' is provided, the default is
`FFTW_ESTIMATE'.
 `FFTW_OUT_OF_PLACE': produce a plan assuming that the input
and output arrays will be distinct (this is the default).
 `FFTW_IN_PLACE': produce a plan assuming that you want to
perform the transform inplace. (Unlike the onedimensional
transform, this "really" performs the transform inplace.)
Note that, if you want to perform inplace transforms, you
*must* use a plan created with this option. The use of this
option has important implications for the size of the
input/output array (*note Computing the Real
Multidimensional Transform: rfftwnd.).
The default mode of operation is `FFTW_OUT_OF_PLACE'.
 `FFTW_USE_WISDOM': use any `wisdom' that is available to help
in the creation of the plan. (*Note Words of Wisdom::.) This
can greatly speed the creation of plans, especially with the
`FFTW_MEASURE' option. `FFTW_ESTIMATE' plans can also take
advantage of `wisdom' to produce a more optimal plan (based
on past measurements) than the estimation heuristic would
normally generate. When the `FFTW_MEASURE' option is used,
new `wisdom' will also be generated if the current transform
size is not completely understood by existing `wisdom'. Note
that the same `wisdom' is shared between onedimensional and
multidimensional transforms.
File: fftw.info, Node: rfftwnd, Next: Array Dimensions for Real Multidimensional Transforms, Prev: rfftwnd_create_plan, Up: Real Multidimensional Transforms Reference
Computing the Real Multidimensional Transform

#include
void rfftwnd_real_to_complex(rfftwnd_plan plan, int howmany,
fftw_real *in, int istride, int idist,
fftw_complex *out, int ostride, int odist);
void rfftwnd_complex_to_real(rfftwnd_plan plan, int howmany,
fftw_complex *in, int istride, int idist,
fftw_real *out, int ostride, int odist);
void rfftwnd_one_real_to_complex(rfftwnd_plan p, fftw_real *in,
fftw_complex *out);
void rfftwnd_one_complex_to_real(rfftwnd_plan p, fftw_complex *in,
fftw_real *out);
These functions compute the real multidimensional Fourier Transform,
using a plan created by `rfftwnd_create_plan' (*note Plan Creation for
Real Multidimensional Transforms: rfftwnd_create_plan.). (Note that
the plan determines the rank and dimensions of the array to be
transformed.) The ``rfftwnd_one_'' functions provide a simplified
interface for the common case of single input array of stride 1.
Unlike other transform routines in FFTW, we here use separate functions
for the two directions of the transform in order to correctly express
the datatypes of the parameters.
*Important:* When invoked for an outofplace,
`FFTW_COMPLEX_TO_REAL' transform with `rank > 1', the input array is
overwritten with scratch values by these routines. The input array is
not modified for `FFTW_REAL_TO_COMPLEX' transforms or for
`FFTW_COMPLEX_TO_REAL' with `rank == 1'.
Arguments
.........
* `plan' is the plan created by `rfftwnd_create_plan'. (*note Plan
Creation for Real Multidimensional Transforms:
rfftwnd_create_plan.). In the case of two and threedimensional
transforms, it could also have been created by
`rfftw2d_create_plan' or `rfftw3d_create_plan', respectively.
`FFTW_REAL_TO_COMPLEX' plans must be used with the
``real_to_complex'' functions, and `FFTW_COMPLEX_TO_REAL' plans
must be used with the ``complex_to_real'' functions. It is an
error to mismatch the plan direction and the transform function.
* `howmany' is the number of transforms to be computed.
* `in', `istride' and `idist' describe the input array(s). There
are `howmany' input arrays; the first one is pointed to by `in',
the second one is pointed to by `in + idist', and so on, up to `in
+ (howmany  1) * idist'. Each input array is stored in rowmajor
format (*note Multidimensional Array Format::.), and is not
necessarily contiguous in memory. Specifically, `in[0]' is the
first element of the first array, `in[istride]' is the second
element of the first array, and so on. In general, the `i'th
element of the `j'th input array will be in position `in[i *
istride + j * idist]'. Note that, here, `i' refers to an index into
the rowmajor format for the multidimensional array, rather than
an index in any particular dimension.
The dimensions of the arrays are different for real and complex
data, and are discussed in more detail below (*note Array
Dimensions for Real Multidimensional Transforms::.).
 *Inplace transforms*: For plans created with the
`FFTW_IN_PLACE' option, the transform is computed
inplacethe output is returned in the `in' array. The
meaning of the `stride' and `dist' parameters in this case is
subtle and is discussed below (*note Strides in Inplace
RFFTWND::.).
* `out', `ostride' and `odist' describe the output array(s). The
format is the same as that for the input array. See below for a
discussion of the dimensions of the output array for real and
complex data.
 *Inplace transforms*: These parameters are ignored for plans
created with the `FFTW_IN_PLACE' option.
The function `rfftwnd_one' transforms a single, contiguous input
array to a contiguous output array. By definition, the call
rfftwnd_one_...(plan, in, out)
is equivalent to
rfftwnd_...(plan, 1, in, 1, 1, out, 1, 1)
linuxx86_64/info/fftw.info30000644003427200235140000014247310015476203014367 0ustar jimnamdThis is Info file fftw.info, produced by Makeinfo version 1.68 from the
input file fftw.texi.
This is the FFTW User's manual.
Copyright (C) 19971999 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.
File: fftw.info, Node: Array Dimensions for Real Multidimensional Transforms, Next: Strides in Inplace RFFTWND, Prev: rfftwnd, Up: Real Multidimensional Transforms Reference
Array Dimensions for Real Multidimensional Transforms

The output of a multidimensional transform of real data contains
symmetries that, in principle, make half of the outputs redundant
(*note What RFFTWND Really Computes::.). In practice, it is not
possible to entirely realize these savings in an efficient and
understandable format. Instead, the output of the rfftwnd transforms is
*slightly* over half of the output of the corresponding complex
transform. We do not "pack" the data in any way, but store it as an
ordinary array of `fftw_complex' values. In fact, this data is simply
a subsection of what would be the array in the corresponding complex
transform.
Specifically, for a real transform of dimensions n1 x n2 x ... x nd,
the complex data is an n1 x n2 x ... x (nd/2+1) array of `fftw_complex'
values in rowmajor order (with the division rounded down). That is,
we only store the lower half (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.)
Since the complex data is slightly larger than the real data, some
complications arise for inplace transforms. In this case, the final
dimension of the real data must be padded with extra values to
accommodate the size of the complex datatwo 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 * (nd/2+1) `fftw_real' values
(exactly enough to hold the complex data). This physical array size
does not, however, change the *logical* array sizeonly nd values are
actually stored in the last dimension, and nd is the last dimension
passed to `rfftwnd_create_plan'.
File: fftw.info, Node: Strides in Inplace RFFTWND, Next: rfftwnd_destroy_plan, Prev: Array Dimensions for Real Multidimensional Transforms, Up: Real Multidimensional Transforms Reference
Strides in Inplace RFFTWND

The fact that the input and output datatypes are different for
rfftwnd complicates the meaning of the `stride' and `dist' parameters
of inplace transformsare they in units of `fftw_real' or
`fftw_complex' elements? When reading the input, they are interpreted
in units of the datatype of the input data. When writing the output,
the `istride' and `idist' are translated to the output datatype's
"units" in one of two ways, corresponding to the two most common
situations in which `stride' and `dist' parameters are useful. Below,
we refer to these "translated" parameters as `ostride_t' and `odist_t'.
(Note that these are computed internally by rfftwnd; the actual
`ostride' and `odist' parameters are ignored for inplace transforms.)
First, there is the case where you are transforming a number of
contiguous arrays located one after another in memory. In this
situation, `istride' is `1' and `idist' is the product of the physical
dimensions of the array. `ostride_t' and `odist_t' are then chosen so
that the output arrays are contiguous and lie on top of the input
arrays. `ostride_t' is therefore `1'. For a realtocomplex
transform, `odist_t' is `idist/2'; for a complextoreal transform,
`odist_t' is `idist*2'.
The second case is when you have an array in which each element has
`nc' components (e.g. a structure with `nc' numeric fields), and you
want to transform all of the components at once. Here, `istride' is
`nc' and `idist' is `1'. For this case, it is natural to want the
output to also have `nc' consecutive components, now of the output data
type; this is exactly what rfftwnd does. Specifically, it uses an
`ostride_t' equal to `istride', and an `odist_t' of `1'. (Astute
readers will realize that some extra buffer space is required in order
to perform such a transform; this is handled automatically by rfftwnd.)
The general rule is as follows. `ostride_t' equals `istride'. If
`idist' is `1' and `idist' is less than `istride', then `odist_t' is
`1'. Otherwise, for a realtocomplex transform `odist_t' is `idist/2'
and for a complextoreal transform `odist_t' is `idist*2'.
File: fftw.info, Node: rfftwnd_destroy_plan, Next: What RFFTWND Really Computes, Prev: Strides in Inplace RFFTWND, Up: Real Multidimensional Transforms Reference
Destroying a Multidimensional Plan

#include
void rfftwnd_destroy_plan(rfftwnd_plan plan);
The function `rfftwnd_destroy_plan' frees the plan `plan' and
releases all the memory associated with it. After destruction, a plan
is no longer valid.
File: fftw.info, Node: What RFFTWND Really Computes, Prev: rfftwnd_destroy_plan, Up: Real Multidimensional Transforms Reference
What RFFTWND Really Computes

The conventions that we follow for the real multidimensional
transform are analogous to those for the complex multidimensional
transform. In particular, the forward transform has a negative sign in
the exponent and neither the forward nor the backward transforms will
perform any normalization. Computing the backward transform of the
forward transform will multiply the array by the product of its
dimensions (that is, the logical dimensions of the real data). The
forward transform is realtocomplex and the backward transform is
complextoreal.
The TeX version of this manual contains the exact definition of the
ndimensional transform RFFTWND uses. It is not possible to display
the definition on a ASCII terminal properly.
File: fftw.info, Node: Wisdom Reference, Next: Memory Allocator Reference, Prev: Real Multidimensional Transforms Reference, Up: FFTW Reference
Wisdom Reference
================
* Menu:
* fftw_export_wisdom::
* fftw_import_wisdom::
* fftw_forget_wisdom::
File: fftw.info, Node: fftw_export_wisdom, Next: fftw_import_wisdom, Prev: Wisdom Reference, Up: Wisdom Reference
Exporting Wisdom

#include
void fftw_export_wisdom(void (*emitter)(char c, void *), void *data);
void fftw_export_wisdom_to_file(FILE *output_file);
char *fftw_export_wisdom_to_string(void);
These functions allow you to export all currently accumulated
`wisdom' in a form from which it can be later imported and restored,
even during a separate run of the program. (*Note Words of Wisdom::.)
The current store of `wisdom' is not affected by calling any of these
routines.
`fftw_export_wisdom' exports the `wisdom' to any output medium, as
specified by the callback function `emitter'. `emitter' is a
`putc'like function that writes the character `c' to some output; its
second parameter is the `data' pointer passed to `fftw_export_wisdom'.
For convenience, the following two "wrapper" routines are provided:
`fftw_export_wisdom_to_file' writes the `wisdom' to the current
position in `output_file', which should be open with write permission.
Upon exit, the file remains open and is positioned at the end of the
`wisdom' data.
`fftw_export_wisdom_to_string' returns a pointer to a
`NULL'terminated string holding the `wisdom' data. This string is
dynamically allocated, and it is the responsibility of the caller to
deallocate it with `fftw_free' when it is no longer needed.
All of these routines export the wisdom in the same format, which we
will not document here except to say that it is LISPlike ASCII text
that is insensitive to white space.
File: fftw.info, Node: fftw_import_wisdom, Next: fftw_forget_wisdom, Prev: fftw_export_wisdom, Up: Wisdom Reference
Importing Wisdom

#include
fftw_status fftw_import_wisdom(int (*get_input)(void *), void *data);
fftw_status fftw_import_wisdom_from_file(FILE *input_file);
fftw_status fftw_import_wisdom_from_string(const char *input_string);
These functions import `wisdom' into a program from data stored by
the `fftw_export_wisdom' functions above. (*Note Words of Wisdom::.)
The imported `wisdom' supplements rather than replaces any `wisdom'
already accumulated by the running program (except when there is
conflicting `wisdom', in which case the existing wisdom is replaced).
`fftw_import_wisdom' imports `wisdom' from any input medium, as
specified by the callback function `get_input'. `get_input' is a
`getc'like function that returns the next character in the input; its
parameter is the `data' pointer passed to `fftw_import_wisdom'. If the
end of the input data is reached (which should never happen for valid
data), it may return either `NULL' (ASCII 0) or `EOF' (as defined in
`'). For convenience, the following two "wrapper" routines
are provided:
`fftw_import_wisdom_from_file' reads `wisdom' from the current
position in `input_file', which should be open with read permission.
Upon exit, the file remains open and is positioned at the end of the
`wisdom' data.
`fftw_import_wisdom_from_string' reads `wisdom' from the
`NULL'terminated string `input_string'.
The return value of these routines is `FFTW_SUCCESS' if the wisdom
was read successfully, and `FFTW_FAILURE' otherwise. Note that, in all
of these functions, any data in the input stream past the end of the
`wisdom' data is simply ignored (it is not even read if the `wisdom'
data is wellformed).
File: fftw.info, Node: fftw_forget_wisdom, Prev: fftw_import_wisdom, Up: Wisdom Reference
Forgetting Wisdom

#include
void fftw_forget_wisdom(void);
Calling `fftw_forget_wisdom' causes all accumulated `wisdom' to be
discarded and its associated memory to be freed. (New `wisdom' can
still be gathered subsequently, however.)
File: fftw.info, Node: Memory Allocator Reference, Next: Thread safety, Prev: Wisdom Reference, Up: FFTW Reference
Memory Allocator Reference
==========================
#include
void *(*fftw_malloc_hook) (size_t n);
void (*fftw_free_hook) (void *p);
Whenever it has to allocate and release memory, FFTW ordinarily calls
`malloc' and `free'. If `malloc' fails, FFTW prints an error message
and exits. This behavior may be undesirable in some applications.
Also, special memoryhandling functions may be necessary in certain
environments. Consequently, FFTW provides means by which you can install
your own memory allocator and take whatever errorcorrecting action you
find appropriate. The variables `fftw_malloc_hook' and
`fftw_free_hook' are pointers to functions, and they are normally
`NULL'. If you set those variables to point to other functions, then
FFTW will use your routines instead of `malloc' and `free'.
`fftw_malloc_hook' must point to a `malloc'like function, and
`fftw_free_hook' must point to a `free'like function.
File: fftw.info, Node: Thread safety, Prev: Memory Allocator Reference, Up: FFTW Reference
Thread safety
=============
Users writing multithreaded programs must concern themselves with
the "thread safety" of the libraries they usethat is, whether it is
safe to call routines in parallel from multiple threads. FFTW can be
used in such an environment, but some care must be taken because certain
parts of FFTW use private global variables to share data between calls.
In particular, the plancreation functions share trigonometric tables
and accumulated `wisdom'. (Users should note that these comments only
apply to programs using sharedmemory threads. Parallelism using MPI
or forked processes involves a separate addressspace and global
variables for each process, and is not susceptible to problems of this
sort.)
The central restriction of FFTW is that it is not safe to create
multiple plans in parallel. You must either create all of your plans
from a single thread, or instead use a semaphore, mutex, or other
mechanism to ensure that different threads don't attempt to create plans
at the same time. The same restriction also holds for destruction of
plans and importing/forgetting `wisdom'. Once created, a plan may
safely be used in any thread.
The actual transform routines in FFTW (`fftw_one', etcetera) are
reentrant and threadsafe, so it is fine to call them simultaneously
from multiple threads. Another question arises, howeveris it safe to
use the *same plan* for multiple transforms in parallel? (It would be
unsafe if, for example, the plan were modified in some way by the
transform.) We address this question by defining an additional planner
flag, `FFTW_THREADSAFE'. When included in the flags for any of the
plancreation routines, `FFTW_THREADSAFE' guarantees that the resulting
plan will be readonly and safe to use in parallel by multiple threads.
File: fftw.info, Node: Parallel FFTW, Next: Calling FFTW from Fortran, Prev: FFTW Reference, Up: Top
Parallel FFTW
*************
In this chapter we discuss the use of FFTW in a parallel environment,
documenting the different parallel libraries that we have provided.
(Users calling FFTW from a multithreaded program should also consult
*Note Thread safety::.) The FFTW package currently contains three
parallel transform implementations that leverage the uniprocessor FFTW
code:
* The first set of routines utilizes sharedmemory threads for
parallel one and multidimensional transforms of both real and
complex data. Any program using FFTW can be trivially modified to
use the multithreaded routines. This code can use any common
threads implementation, including POSIX threads. (POSIX threads
are available on most Unix variants, including Linux.) These
routines are located in the `threads' directory, and are
documented in *Note Multithreaded FFTW::.
* The `mpi' directory contains multidimensional transforms of real
and complex data for parallel machines supporting MPI. It also
includes parallel onedimensional transforms for complex data.
The main feature of this code is that it supports
distributedmemory transforms, so it runs on everything from
workstation clusters to massivelyparallel supercomputers. More
information on MPI can be found at the MPI home page (http://www.mcs.anl.gov/mpi). The FFTW MPI routines are documented in *Note MPI
FFTW::.
* We also have an experimental parallel implementation written in
Cilk, a Clike parallel language developed at MIT and currently
available for several SMP platforms. For more information on Cilk
see the Cilk home page (http://supertech.lcs.mit.edu/cilk). The
FFTW Cilk code can be found in the `cilk' directory, with
parallelized one and multidimensional transforms of complex
data. The Cilk FFTW routines are documented in `cilk/README'.
* Menu:
* Multithreaded FFTW::
* MPI FFTW::
File: fftw.info, Node: Multithreaded FFTW, Next: MPI FFTW, Prev: Parallel FFTW, Up: Parallel FFTW
Multithreaded FFTW
===================
In this section we document the parallel FFTW routines for
sharedmemory threads on SMP hardware. These routines, which support
parallel one and multidimensional 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 they take the number of parallel threads to use
as an extra parameter. Any program that uses the uniprocessor FFTW can
be trivially modified to use the multithreaded FFTW.
* Menu:
* Installation and Supported Hardware/Software::
* Usage of Multithreaded FFTW::
* How Many Threads to Use?::
* Using Multithreaded FFTW in a Multithreaded Program::
* Tips for Optimal Threading::
File: fftw.info, Node: Installation and Supported Hardware/Software, Next: Usage of Multithreaded FFTW, Prev: Multithreaded FFTW, Up: Multithreaded FFTW
Installation and Supported Hardware/Software

All of the FFTW threads code is located in the `threads'
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 `enablethreads' in the flags to the `configure' script
(*note Installation on Unix::.). (Note also that the threads routines,
when enabled, are automatically tested by the ``make check''
selftests.)
The threads routines require your operating system to have some sort
of sharedmemory threads support. Specifically, the FFTW threads
package works with POSIX threads (available on most Unix variants,
including Linux), Solaris threads, BeOS (http://www.be.com) threads
(tested on BeOS DR8.2), Mach C threads (reported to work by users), and
Win32 threads (reported to work by users). (There is also untested
code to use MacOS MP threads.) If you have a sharedmemory machine
that uses a different threads API, it should be a simple matter of
programming to include support for it; see the file
`fftw_threadsint.h' for more detail.
SMP hardware is not required, although of course you need multiple
processors to get any benefit from the multithreaded transforms.
File: fftw.info, Node: Usage of Multithreaded FFTW, Next: How Many Threads to Use?, Prev: Installation and Supported Hardware/Software, Up: Multithreaded FFTW
Usage of Multithreaded FFTW

Here, it is assumed that the reader is already familiar with the
usage of the uniprocessor FFTW routines, described elsewhere in this
manual. We only describe what one has to change in order to use the
multithreaded routines.
First, instead of including `' or `', you should
include the files `' or `',
respectively.
Second, before calling any FFTW routines, you should call the
function:
int fftw_threads_init(void);
This function, which should only be called once (probably in your
`main()' function), performs any onetime initialization required to
use threads on your system. It returns zero if successful, and a
nonzero value if there was an error (in which case, something is
seriously wrong and you should probably exit the program).
Third, when you want to actually compute the transform, you should
use one of the following transform routines instead of the ordinary FFTW
functions:
fftw_threads(nthreads, plan, howmany, in, istride,
idist, out, ostride, odist);
fftw_threads_one(nthreads, plan, in, out);
fftwnd_threads(nthreads, plan, howmany, in, istride,
idist, out, ostride, odist);
fftwnd_threads_one(nthreads, plan, in, out);
rfftw_threads(nthreads, plan, howmany, in, istride,
idist, out, ostride, odist);
rfftw_threads_one(nthreads, plan, in, out);
rfftwnd_threads_real_to_complex(nthreads, plan, howmany, in,
istride, idist, out, ostride, odist);
rfftwnd_threads_one_real_to_complex(nthreads, plan, in, out);
rfftwnd_threads_complex_to_real(nthreads, plan, howmany, in,
istride, idist, out, ostride, odist);
rfftwnd_threads_one_real_to_complex(nthreads, plan, in, out);
rfftwnd_threads_one_complex_to_real(nthreads, plan, in, out);
All of these routines take exactly the same arguments and have
exactly the same effects as their uniprocessor counterparts (i.e.
without the ``_threads'') *except* that they take one extra parameter,
`nthreads' (of type `int'), before the normal parameters.(1) The
`nthreads' parameter specifies the number of threads of execution to
use when performing the transform (actually, the maximum number of
threads).
For example, to parallelize a single onedimensional transform of
complex data, instead of calling the uniprocessor `fftw_one(plan, in,
out)', you would call `fftw_threads_one(nthreads, plan, in, out)'.
Passing an `nthreads' of `1' means to use only one thread (the main
thread), and is equivalent to calling the uniprocessor routine.
Passing an `nthreads' of `2' means that the transform is potentially
parallelized over two threads (and two processors, if you have them),
and so on.
These are the only changes you need to make to your source code.
Calls to all other FFTW routines (plan creation, destruction, wisdom,
etcetera) are not parallelized and remain the same. (The same plans and
wisdom are used by both uniprocessor and multithreaded transforms.)
Your arrays are allocated and formatted in the same way, and so on.
Programs using the parallel complex transforms should be linked with
`lfftw_threads lfftw lm' on Unix. Programs using the parallel real
transforms should be linked with `lrfftw_threads lfftw_threads
lrfftw lfftw lm'. You will also need to link with whatever library
is responsible for threads on your system (e.g. `lpthread' on Linux).
 Footnotes 
(1) There is one exception: when performing onedimensional inplace
transforms, the `out' parameter is always ignored by the multithreaded
routines, instead of being used as a workspace if it is non`NULL' as
in the uniprocessor routines. The multithreaded routines always
allocate their own workspace (the size of which depends upon the number
of threads).
File: fftw.info, Node: How Many Threads to Use?, Next: Using Multithreaded FFTW in a Multithreaded Program, Prev: Usage of Multithreaded FFTW, Up: Multithreaded FFTW
How Many Threads to Use?

There is a fair amount of overhead involved in spawning and
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.
As a general rule, you don'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.
You will have to experiment with your system to see what level of
parallelization is best for your problem size. Useful tools to help you
do this are the test programs that are automatically compiled along with
the threads libraries, `fftw_threads_test' and `rfftw_threads_test' (in
the `threads' subdirectory). These take the same arguments as the
other FFTW test programs (see `tests/README'), except that they also
take the number of threads to use as a first argument, and report the
parallel speedup in speed tests. For example,
fftw_threads_test 2 s 128x128
will benchmark complex 128x128 transforms using two threads and
report the speedup relative to the uniprocessor transform.
For instance, on a 4processor 200MHz Pentium Pro system running
Linux 2.2.0, we found that the "crossover" point at which 2 threads
became beneficial for complex transforms was about 4k points, while 4
threads became beneficial at 8k points.
File: fftw.info, Node: Using Multithreaded FFTW in a Multithreaded Program, Next: Tips for Optimal Threading, Prev: How Many Threads to Use?, Up: Multithreaded FFTW
Using Multithreaded FFTW in a Multithreaded Program

It is perfectly possible to use the multithreaded FFTW routines
from a multithreaded program (e.g. have multiple threads computing
multithreaded transforms simultaneously). If you have the processors,
more power to you! However, the same restrictions apply as for the
uniprocessor FFTW routines (*note Thread safety::.). In particular, you
should recall that you may not create or destroy plans in parallel.
File: fftw.info, Node: Tips for Optimal Threading, Prev: Using Multithreaded FFTW in a Multithreaded Program, Up: Multithreaded FFTW
Tips for Optimal Threading

Not all transforms are equally wellparallelized by the
multithreaded FFTW routines. (This is merely a consequence of
laziness on the part of the implementors, and is not inherent to the
algorithms employed.) Mainly, the limitations are in the parallel
onedimensional transforms. The things to avoid if you want optimal
parallelization are as follows:
Parallelization deficiencies in onedimensional transforms

* Large prime factors can sometimes parallelize poorly. Of course,
you should avoid these anyway if you want high performance.
* Single inplace transforms don't parallelize completely. (Multiple
inplace transforms, i.e. `howmany > 1', are fine.) Again, you
should avoid these in any case if you want high performance, as
they require transforming to a scratch array and copying back.
* Single realcomplex (`rfftw') transforms don't parallelize
completely. This is unfortunate, but parallelizing this correctly
would have involved a lot of extra code (and a much larger
library). You still get some benefit from additional processors,
but if you have a very large number of processors you will
probably be better off using the parallel complex (`fftw')
transforms. Note that multidimensional real transforms or
multiple onedimensional real transforms are fine.
File: fftw.info, Node: MPI FFTW, Prev: Multithreaded FFTW, Up: Parallel FFTW
MPI FFTW
========
This section describes the MPI FFTW routines for distributedmemory
(and sharedmemory) machines supporting MPI (Message Passing
Interface). The MPI routines are significantly different from the
ordinary FFTW because the transform data here are *distributed* over
multiple processes, so that each process gets only a portion of the
array. Currently, multidimensional transforms of both real and
complex data, as well as onedimensional transforms of complex data,
are supported.
* Menu:
* MPI FFTW Installation::
* Usage of MPI FFTW for Complex Multidimensional Transforms::
* MPI Data Layout::
* Usage of MPI FFTW for Real Multidimensional Transforms::
* Usage of MPI FFTW for Complex Onedimensional Transforms::
* MPI Tips::
File: fftw.info, Node: MPI FFTW Installation, Next: Usage of MPI FFTW for Complex Multidimensional Transforms, Prev: MPI FFTW, Up: MPI FFTW
MPI FFTW Installation

The FFTW MPI library code is all located in the `mpi' subdirectoy of
the FFTW package (along with source code for test programs). On Unix
systems, the FFTW MPI libraries and header files can be automatically
configured, compiled, and installed along with the uniprocessor FFTW
libraries simply by including `enablempi' in the flags to the
`configure' script (*note Installation on Unix::.).
The only requirement of the FFTW MPI code is that you have the
standard MPI 1.1 (or later) libraries and header files installed on
your system. A free implementation of MPI is available from
the MPICH home page (http://wwwunix.mcs.anl.gov/mpi/mpich/).
Previous versions of the FFTW MPI routines have had an unfortunate
tendency to expose bugs in MPI implementations. The current version has
been largely rewritten, and hopefully avoids some of the problems. If
you run into difficulties, try passing the optional workspace to
`(r)fftwnd_mpi' (see below), as this allows us to use the standard (and
hopefully welltested) `MPI_Alltoall' primitive for communications.
Please let us know () how things work out.
Several test programs are included in the `mpi' directory. The ones
most useful to you are probably the `fftw_mpi_test' and
`rfftw_mpi_test' programs, which are run just like an ordinary MPI
program and accept the same parameters as the other FFTW test programs
(c.f. `tests/README'). For example, `mpirun ...params...
fftw_mpi_test r 0' will run nonterminating complextransform
correctness tests of random dimensions. They can also do performance
benchmarks.
File: fftw.info, Node: Usage of MPI FFTW for Complex Multidimensional Transforms, Next: MPI Data Layout, Prev: MPI FFTW Installation, Up: MPI FFTW
Usage of MPI FFTW for Complex Multidimensional Transforms

Usage of the MPI FFTW routines is similar to that of the uniprocessor
FFTW. We assume that the reader already understands the usage of the
uniprocessor FFTW routines, described elsewhere in this manual. Some
familiarity with MPI is also helpful.
A typical program performing a complex twodimensional MPI transform
might look something like:
#include
int main(int argc, char **argv)
{
const int NX = ..., NY = ...;
fftwnd_mpi_plan plan;
fftw_complex *data;
MPI_Init(&argc,&argv);
plan = fftw2d_mpi_create_plan(MPI_COMM_WORLD,
NX, NY,
FFTW_FORWARD, FFTW_ESTIMATE);
...allocate and initialize data...
fftwnd_mpi(p, 1, data, NULL, FFTW_NORMAL_ORDER);
...
fftwnd_mpi_destroy_plan(plan);
MPI_Finalize();
}
The calls to `MPI_Init' and `MPI_Finalize' are required in all MPI
programs; see the MPI home page (http://www.mcs.anl.gov/mpi/) for more
information. Note that all of your processes run the program in
parallel, as a group; there is no explicit launching of
threads/processes in an MPI program.
As in the ordinary FFTW, the first thing we do is to create a plan
(of type `fftwnd_mpi_plan'), using:
fftwnd_mpi_plan fftw2d_mpi_create_plan(MPI_Comm comm,
int nx, int ny,
fftw_direction dir, int flags);
Except for the first argument, the parameters are identical to those
of `fftw2d_create_plan'. (There are also analogous
`fftwnd_mpi_create_plan' and `fftw3d_mpi_create_plan' functions.
Transforms of any rank greater than one are supported.) The first
argument is an MPI "communicator", which specifies the group of
processes that are to be involved in the transform; the standard
constant `MPI_COMM_WORLD' indicates all available processes.
Next, one has to allocate and initialize the data. This is somewhat
tricky, because the transform data is distributed across the processes
involved in the transform. It is discussed in detail by the next
section (*note MPI Data Layout::.).
The actual computation of the transform is performed by the function
`fftwnd_mpi', which differs somewhat from its uniprocessor equivalent
and is described by:
void fftwnd_mpi(fftwnd_mpi_plan p,
int n_fields,
fftw_complex *local_data, fftw_complex *work,
fftwnd_mpi_output_order output_order);
There are several things to notice here:
* First of all, all `fftw_mpi' transforms are inplace: the output is
in the `local_data' parameter, and there is no need to specify
`FFTW_IN_PLACE' in the plan flags.
* The MPI transforms also only support a limited subset of the
`howmany'/`stride'/`dist' functionality of the uniprocessor
routines: the `n_fields' parameter is equivalent to
`howmany=n_fields', `stride=n_fields', and `dist=1'.
(Conceptually, the `n_fields' parameter allows you to transform an
array of contiguous vectors, each with length `n_fields'.)
`n_fields' is `1' if you are only transforming a single, ordinary
array.
* The `work' parameter is an optional workspace. If it is not
`NULL', it should be exactly the same size as the `local_data'
array. If it is provided, FFTW is able to use the builtin
`MPI_Alltoall' primitive for (often) greater efficiency at the
expense of extra storage space.
* Finally, the last parameter specifies whether the output data has
the same ordering as the input data (`FFTW_NORMAL_ORDER'), or if
it is transposed (`FFTW_TRANSPOSED_ORDER'). Leaving the data
transposed results in significant performance improvements due to
a saved communication step (needed to untranspose the data).
Specifically, the first two dimensions of the array are
transposed, as is described in more detail by the next section.
The output of `fftwnd_mpi' is identical to that of the corresponding
uniprocessor transform. In particular, you should recall our
conventions for normalization and the sign of the transform exponent.
The same plan can be used to compute many transforms of the same
size. After you are done with it, you should deallocate it by calling
`fftwnd_mpi_destroy_plan'.
Important: The FFTW MPI routines must be called in the same order by
all processes involved in the transform. You should assume that they
all are blocking, as if each contained a call to `MPI_Barrier'.
Programs using the FFTW MPI routines should be linked with
`lfftw_mpi lfftw lm' on Unix, in addition to whatever libraries are
required for MPI.
File: fftw.info, Node: MPI Data Layout, Next: Usage of MPI FFTW for Real Multidimensional Transforms, Prev: Usage of MPI FFTW for Complex Multidimensional Transforms, Up: MPI FFTW
MPI Data Layout

The transform data used by the MPI FFTW routines is "distributed": a
distinct portion of it resides with each process involved in the
transform. This allows the transform to be parallelized, for example,
over a cluster of workstations, each with its own separate memory, so
that you can take advantage of the total memory of all the processors
you are parallelizing over.
In particular, the array is divided according to the rows (first
dimension) of the data: each process gets a subset of the rows of the
data. (This is sometimes called a "slab decomposition.") One
consequence of this is that you can't take advantage of more processors
than you have rows (e.g. `64x64x64' matrix can at most use 64
processors). This isn't usually much of a limitation, however, as each
processor needs a fair amount of data in order for the
parallelcomputation benefits to outweight the communications costs.
Below, the first dimension of the data will be referred to as ``x''
and the second dimension as ``y''.
FFTW supplies a routine to tell you exactly how much data resides on
the current process:
void fftwnd_mpi_local_sizes(fftwnd_mpi_plan p,
int *local_nx,
int *local_x_start,
int *local_ny_after_transpose,
int *local_y_start_after_transpose,
int *total_local_size);
Given a plan `p', the other parameters of this routine are set to
values describing the required data layout, described below.
`total_local_size' is the number of `fftw_complex' elements that you
must allocate for your local data (and workspace, if you choose).
(This value should, of course, be multiplied by `n_fields' if that
parameter to `fftwnd_mpi' is not `1'.)
The data on the current process has `local_nx' rows, starting at row
`local_x_start'. If `fftwnd_mpi' is called with
`FFTW_TRANSPOSED_ORDER' output, then `y' will be the first dimension of
the output, and the local `y' extent will be given by
`local_ny_after_transpose' and `local_y_start_after_transpose'.
Otherwise, the output has the same dimensions and layout as the input.
For instance, suppose you want to transform threedimensional data of
size `nx x ny x nz'. Then, the current process will store a subset of
this data, of size `local_nx x ny x nz', where the `x' indices
correspond to the range `local_x_start' to `local_x_start+local_nx1'
in the "real" (i.e. logical) array. If `fftwnd_mpi' is called with
`FFTW_TRANSPOSED_ORDER' output, then the result will be a `ny x nx x
nz' array, of which a `local_ny_after_transpose x nx x nz' subset is
stored on the current process (corresponding to `y' values starting at
`local_y_start_after_transpose').
The following is an example of allocating such a threedimensional
array array (`local_data') before the transform and initializing it to
some function `f(x,y,z)':
fftwnd_mpi_local_sizes(plan, &local_nx, &local_x_start,
&local_ny_after_transpose,
&local_y_start_after_transpose,
&total_local_size);
local_data = (fftw_complex*) malloc(sizeof(fftw_complex) *
total_local_size);
for (x = 0; x < local_nx; ++x)
for (y = 0; y < ny; ++y)
for (z = 0; z < nz; ++z)
local_data[(x*ny + y)*nz + z]
= f(x + local_x_start, y, z);
Some important things to remember:
* Although the local data is of dimensions `local_nx x ny x nz' in
the above example, do *not* allocate the array to be of size
`local_nx*ny*nz'. Use `total_local_size' instead.
* The amount of data on each process will not necessarily be the
same; in fact, `local_nx' may even be zero for some processes.
(For example, suppose you are doing a `6x6' transform on four
processors. There is no way to effectively use the fourth
processor in a slab decomposition, so we leave it empty. Proof
left as an exercise for the reader.)
* All arrays are, of course, in rowmajor order (*note
Multidimensional Array Format::.).
* If you want to compute the inverse transform of the output of
`fftwnd_mpi', the dimensions of the inverse transform are given by
the dimensions of the output of the forward transform. For
example, if you are using `FFTW_TRANSPOSED_ORDER' output in the
above example, then the inverse plan should be created with
dimensions `ny x nx x nz'.
* The data layout only depends upon the dimensions of the array, not
on the plan, so you are guaranteed that different plans for the
same size (or inverse plans) will use the same (consistent) data
layouts.
File: fftw.info, Node: Usage of MPI FFTW for Real Multidimensional Transforms, Next: Usage of MPI FFTW for Complex Onedimensional Transforms, Prev: MPI Data Layout, Up: MPI FFTW
Usage of MPI FFTW for Real Multidimensional Transforms

MPI transforms specialized for real data are also available,
similiar to the uniprocessor `rfftwnd' transforms. Just as in the
uniprocessor case, the realdata MPI functions gain roughly a factor of
two in speed (and save a factor of two in space) at the expense of more
complicated data formats in the calling program. Before reading this
section, you should definitely understand how to call the uniprocessor
`rfftwnd' functions and also the complex MPI FFTW functions.
The following is an example of a program using `rfftwnd_mpi'. It
computes the size `nx x ny x nz' transform of a real function
`f(x,y,z)', multiplies the imaginary part by `2' for fun, then computes
the inverse transform. (We'll also use `FFTW_TRANSPOSED_ORDER' output
for the transform, and additionally supply the optional workspace
parameter to `rfftwnd_mpi', just to add a little spice.)
#include
int main(int argc, char **argv)
{
const int nx = ..., ny = ..., nz = ...;
int local_nx, local_x_start, local_ny_after_transpose,
local_y_start_after_transpose, total_local_size;
int x, y, z;
rfftwnd_mpi_plan plan, iplan;
fftw_real *data, *work;
fftw_complex *cdata;
MPI_Init(&argc,&argv);
/* create the forward and backward plans: */
plan = rfftw3d_mpi_create_plan(MPI_COMM_WORLD,
nx, ny, nz,
FFTW_REAL_TO_COMPLEX,
FFTW_ESTIMATE);
iplan = rfftw3d_mpi_create_plan(MPI_COMM_WORLD,
/* dim.'s of REAL data > */ nx, ny, nz,
FFTW_COMPLEX_TO_REAL,
FFTW_ESTIMATE);
rfftwnd_mpi_local_sizes(plan, &local_nx, &local_x_start,
&local_ny_after_transpose,
&local_y_start_after_transpose,
&total_local_size);
data = (fftw_real*) malloc(sizeof(fftw_real) * total_local_size);
/* workspace is the same size as the data: */
work = (fftw_real*) malloc(sizeof(fftw_real) * total_local_size);
/* initialize data to f(x,y,z): */
for (x = 0; x < local_nx; ++x)
for (y = 0; y < ny; ++y)
for (z = 0; z < nz; ++z)
data[(x*ny + y) * (2*(nz/2+1)) + z]
= f(x + local_x_start, y, z);
/* Now, compute the forward transform: */
rfftwnd_mpi(plan, 1, data, work, FFTW_TRANSPOSED_ORDER);
/* the data is now complex, so typecast a pointer: */
cdata = (fftw_complex*) data;
/* multiply imaginary part by 2, for fun:
(note that the data is transposed) */
for (y = 0; y < local_ny_after_transpose; ++y)
for (x = 0; x < nx; ++x)
for (z = 0; z < (nz/2+1); ++z)
cdata[(y*nx + x) * (nz/2+1) + z].im
*= 2.0;
/* Finally, compute the inverse transform; the result
is transposed back to the original data layout: */
rfftwnd_mpi(iplan, 1, data, work, FFTW_TRANSPOSED_ORDER);
free(data);
free(work);
rfftwnd_mpi_destroy_plan(plan);
rfftwnd_mpi_destroy_plan(iplan);
MPI_Finalize();
}
There's a lot of stuff in this example, but it's all just what you
would have guessed, right? We replaced all the `fftwnd_mpi*' functions
by `rfftwnd_mpi*', but otherwise the parameters were pretty much the
same. The data layout distributed among the processes just like for
the complex transforms (*note MPI Data Layout::.), but in addition the
final dimension is padded just like it is for the uniprocessor inplace
real transforms (*note Array Dimensions for Real Multidimensional
Transforms::.). In particular, the `z' dimension of the real input
data is padded to a size `2*(nz/2+1)', and after the transform it
contains `nz/2+1' complex values.
Some other important things to know about the real MPI transforms:
* As for the uniprocessor `rfftwnd_create_plan', the dimensions
passed for the `FFTW_COMPLEX_TO_REAL' plan are those of the *real*
data. In particular, even when `FFTW_TRANSPOSED_ORDER' is used as
in this case, the dimensions are those of the (untransposed) real
output, not the (transposed) complex input. (For the complex MPI
transforms, on the other hand, the dimensions are always those of
the input array.)
* The output ordering of the transform (`FFTW_TRANSPOSED_ORDER' or
`FFTW_TRANSPOSED_ORDER') *must* be the same for both forward and
backward transforms. (This is not required in the complex case.)
* `total_local_size' is the required size in `fftw_real' values, not
`fftw_complex' values as it is for the complex transforms.
* `local_ny_after_transpose' and `local_y_start_after_transpose'
describe the portion of the array after the transform; that is,
they are indices in the complex array for an
`FFTW_REAL_TO_COMPLEX' transform and in the real array for an
`FFTW_COMPLEX_TO_REAL' transform.
* `rfftwnd_mpi' always expects `fftw_real*' array arguments, but of
course these pointers can refer to either real or complex arrays,
depending upon which side of the transform you are on. Just as for
inplace uniprocessor real transforms (and also in the example
above), this is most easily handled by typecasting to a complex
pointer when handling the complex data.
* As with the complex transforms, there are also
`rfftwnd_create_plan' and `rfftw2d_create_plan' functions, and any
rank greater than one is supported.
Programs using the MPI FFTW real transforms should link with
`lrfftw_mpi lfftw_mpi lrfftw lfftw lm' on Unix.
File: fftw.info, Node: Usage of MPI FFTW for Complex Onedimensional Transforms, Next: MPI Tips, Prev: Usage of MPI FFTW for Real Multidimensional Transforms, Up: MPI FFTW
Usage of MPI FFTW for Complex Onedimensional Transforms

The MPI FFTW also includes routines for parallel onedimensional
transforms of complex data (only). Although the speedup is generally
worse than it is for the multidimensional routines,(1) these
distributedmemory onedimensional transforms are especially useful for
performing onedimensional transforms that don't fit into the memory of
a single machine.
The usage of these routines is straightforward, and is similar to
that of the multidimensional MPI transform functions. You first
include the header `' and then create a plan by calling:
fftw_mpi_plan fftw_mpi_create_plan(MPI_Comm comm, int n,
fftw_direction dir, int flags);
The last three arguments are the same as for `fftw_create_plan'
(except that all MPI transforms are automatically `FFTW_IN_PLACE').
The first argument specifies the group of processes you are using, and
is usually `MPI_COMM_WORLD' (all processes). A plan can be used for
many transforms of the same size, and is destroyed when you are done
with it by calling `fftw_mpi_destroy_plan(plan)'.
If you don't care about the ordering of the input or output data of
the transform, you can include `FFTW_SCRAMBLED_INPUT' and/or
`FFTW_SCRAMBLED_OUTPUT' in the `flags'. These save some communications
at the expense of having the input and/or output reordered in an
undocumented way. For example, if you are performing an FFTbased
convolution, you might use `FFTW_SCRAMBLED_OUTPUT' for the forward
transform and `FFTW_SCRAMBLED_INPUT' for the inverse transform.
The transform itself is computed by:
void fftw_mpi(fftw_mpi_plan p, int n_fields,
fftw_complex *local_data, fftw_complex *work);
`n_fields', as in `fftwnd_mpi', is equivalent to `howmany=n_fields',
`stride=n_fields', and `dist=1', and should be `1' when you are
computing the transform of a single array. `local_data' contains the
portion of the array local to the current process, described below.
`work' is either `NULL' or an array exactly the same size as
`local_data'; in the latter case, FFTW can use the `MPI_Alltoall'
communications primitive which is (usually) faster at the expense of
extra storage. Upon return, `local_data' contains the portion of the
output local to the current process (see below).
To find out what portion of the array is stored local to the current
process, you call the following routine:
void fftw_mpi_local_sizes(fftw_mpi_plan p,
int *local_n, int *local_start,
int *local_n_after_transform,
int *local_start_after_transform,
int *total_local_size);
`total_local_size' is the number of `fftw_complex' elements you
should actually allocate for `local_data' (and `work'). `local_n' and
`local_start' indicate that the current process stores `local_n'
elements corresponding to the indices `local_start' to
`local_start+local_n1' in the "real" array. *After the transform, the
process may store a different portion of the array.* The portion of
the data stored on the process after the transform is given by
`local_n_after_transform' and `local_start_after_transform'. This data
is exactly the same as a contiguous segment of the corresponding
uniprocessor transform output (i.e. an inorder sequence of sequential
frequency bins).
Note that, if you compute both a forward and a backward transform of
the same size, the local sizes are guaranteed to be consistent. That
is, the local size after the forward transform will be the same as the
local size before the backward transform, and vice versa.
Programs using the FFTW MPI routines should be linked with
`lfftw_mpi lfftw lm' on Unix, in addition to whatever libraries are
required for MPI.
 Footnotes 
(1) The 1D transforms require much more communication. All the
communication in our FFT routines takes the form of an alltoall
communication: the multidimensional transforms require two alltoall
communications (or one, if you use `FFTW_TRANSPOSED_ORDER'), while the
onedimensional transforms require *three* (or two, if you use
scrambled input or output).
linuxx86_64/info/fftw.info40000644003427200235140000013434110015476203014363 0ustar jimnamdThis is Info file fftw.info, produced by Makeinfo version 1.68 from the
input file fftw.texi.
This is the FFTW User's manual.
Copyright (C) 19971999 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.
File: fftw.info, Node: MPI Tips, Prev: Usage of MPI FFTW for Complex Onedimensional Transforms, Up: MPI FFTW
MPI Tips

There are several things you should consider in order to get the best
performance out of the MPI FFTW routines.
First, if possible, the first and second dimensions of your data
should be divisible by the number of processes you are using. (If only
one can be divisible, then you should choose the first dimension.)
This allows the computational load to be spread evenly among the
processes, and also reduces the communications complexity and overhead.
In the onedimensional transform case, the size of the transform
should ideally be divisible by the *square* of the number of processors.
Second, you should consider using the `FFTW_TRANSPOSED_ORDER' output
format if it is not too burdensome. The speed gains from
communications savings are usually substantial.
Third, you should consider allocating a workspace for
`(r)fftw(nd)_mpi', as this can often (but not always) improve
performance (at the cost of extra storage).
Fourth, you should experiment with the best number of processors to
use for your problem. (There comes a point of diminishing returns,
when the communications costs outweigh the computational benefits.(1))
The `fftw_mpi_test' program can output helpful performance benchmarks.
It accepts the same parameters as the uniprocessor test programs (c.f.
`tests/README') and is run like an ordinary MPI program. For example,
`mpirun np 4 fftw_mpi_test s 128x128x128' will benchmark a
`128x128x128' transform on four processors, reporting timings and
parallel speedups for all variants of `fftwnd_mpi' (transposed, with
workspace, etcetera). (Note also that there is the `rfftw_mpi_test'
program for the real transforms.)
 Footnotes 
(1) An FFT is particularly hard on communications systems, as it
requires an "alltoall" communication, which is more or less the worst
possible case.
File: fftw.info, Node: Calling FFTW from Fortran, Next: Installation and Customization, Prev: Parallel FFTW, Up: Top
Calling FFTW from Fortran
*************************
The standard FFTW libraries include special wrapper functions that
allow Fortran programs to call FFTW subroutines. This chapter
describes how those functions may be employed to use FFTW from Fortran.
We assume here that the reader is already familiar with the usage of
FFTW in C, as described elsewhere in this manual.
In general, it is not possible to call C functions directly from
Fortran, due to Fortran's inability to pass arguments by value and also
because Fortran compilers typically expect identifiers to be mangled
somehow for linking. However, if C functions are written in a special
way, they *are* callable from Fortran, and we have employed this
technique to create Fortrancallable "wrapper" functions around the
main FFTW routines. These wrapper functions are included in the FFTW
libraries by default, unless a Fortran compiler isn't found on your
system or `disablefortran' is included in the `configure' flags.
As a result, calling FFTW from Fortran requires little more than
appending ``_f77'' to the function names and then linking normally with
the FFTW libraries. There are a few wrinkles, however, as we shall
discuss below.
* Menu:
* Wrapper Routines::
* FFTW Constants in Fortran::
* Fortran Examples::
File: fftw.info, Node: Wrapper Routines, Next: FFTW Constants in Fortran, Prev: Calling FFTW from Fortran, Up: Calling FFTW from Fortran
Wrapper Routines
================
All of the uniprocessor and multithreaded transform routines have
Fortrancallable wrappers, except for the wisdom import/export functions
(since it is not possible to exchange string and file arguments portably
with Fortran) and the specific planner routines (*note Discussion on
Specific Plans::.). The name of the wrapper routine is the same as that
of the corresponding C routine, but with `fftw/fftwnd/rfftw/rfftwnd'
replaced by `fftw_f77/fftwnd_f77/rfftw_f77/rfftwnd_f77'. For example,
in Fortran, instead of calling `fftw_one' you would call
`fftw_f77_one'.(1) For the most part, all of the arguments to the
functions are the same, with the following exceptions:
* `plan' variables (what would be of type `fftw_plan',
`rfftwnd_plan', etcetera, in C), must be declared as a type that is
the same size as a pointer (address) on your machine. (Fortran
has no generic pointer type.) The Fortran `integer' type is
usually the same size as a pointer, but you need to be wary
(especially on 64bit machines). (You could also use `integer*4'
on a 32bit machine and `integer*8' on a 64bit machine.) Ugh.
(`g77' has a special type, `integer(kind=7)', that is defined to
be the same size as a pointer.)
* Any function that returns a value (e.g. `fftw_create_plan') is
converted into a subroutine. The return value is converted into an
additional (first) parameter of the wrapper subroutine. (The
reason for this is that some Fortran implementations seem to have
trouble with C function return values.)
* When performing onedimensional `FFTW_IN_PLACE' transforms, you
don't have the option of passing `NULL' for the `out' argument
(since there is no way to pass `NULL' from Fortran). Therefore,
when performing such transforms, you *must* allocate and pass a
contiguous scratch array of the same size as the transform. Note
that for inplace multidimensional (`(r)fftwnd') transforms, the
`out' argument is ignored, so you can pass anything for that
parameter.
* The wrapper routines expect multidimensional arrays to be in
columnmajor order, which is the ordinary format of Fortran arrays.
They do this transparently and costlessly simply by reversing the
order of the dimensions passed to FFTW, but this has one important
consequence for multidimensional realcomplex transforms,
discussed below.
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. If
your C and Fortran compilers are made by the same vendor, the
correspondence is usually straightforward (i.e. `integer' corresponds
to `int', `real' corresponds to `float', etcetera). Such simple
correspondences are assumed in the examples below. The examples also
assume that FFTW was compiled in double precision (the default).
 Footnotes 
(1) 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't deserve to link to FFTW.
File: fftw.info, Node: FFTW Constants in Fortran, Next: Fortran Examples, Prev: Wrapper Routines, Up: Calling FFTW from Fortran
FFTW Constants in Fortran
=========================
When creating plans in FFTW, a number of constants are used to
specify options, such as `FFTW_FORWARD' or `FFTW_USE_WISDOM'. The same
constants must be used with the wrapper routines, but of course the C
header files where the constants are defined can't be incorporated
directly into Fortran code.
Instead, we have placed Fortran equivalents of the FFTW constant
definitions in the file `fortran/fftw_f77.i' of the FFTW package. If
your Fortran compiler supports a preprocessor, you can use that to
incorporate this file into your code whenever you need to call FFTW.
Otherwise, you will have to paste the constant definitions in directly.
They are:
integer FFTW_FORWARD,FFTW_BACKWARD
parameter (FFTW_FORWARD=1,FFTW_BACKWARD=1)
integer FFTW_REAL_TO_COMPLEX,FFTW_COMPLEX_TO_REAL
parameter (FFTW_REAL_TO_COMPLEX=1,FFTW_COMPLEX_TO_REAL=1)
integer FFTW_ESTIMATE,FFTW_MEASURE
parameter (FFTW_ESTIMATE=0,FFTW_MEASURE=1)
integer FFTW_OUT_OF_PLACE,FFTW_IN_PLACE,FFTW_USE_WISDOM
parameter (FFTW_OUT_OF_PLACE=0)
parameter (FFTW_IN_PLACE=8,FFTW_USE_WISDOM=16)
integer FFTW_THREADSAFE
parameter (FFTW_THREADSAFE=128)
In C, you combine different flags (like `FFTW_USE_WISDOM' and
`FFTW_MEASURE') using the ``'' operator; in Fortran you should just
use ``+''.
File: fftw.info, Node: Fortran Examples, Prev: FFTW Constants in Fortran, Up: Calling FFTW from Fortran
Fortran Examples
================
In C you might have something like the following to transform a
onedimensional complex array:
fftw_complex in[N], *out[N];
fftw_plan plan;
plan = fftw_create_plan(N,FFTW_FORWARD,FFTW_ESTIMATE);
fftw_one(plan,in,out);
fftw_destroy_plan(plan);
In Fortran, you use the following to accomplish the same thing:
double complex in, out
dimension in(N), out(N)
integer plan
call fftw_f77_create_plan(plan,N,FFTW_FORWARD,FFTW_ESTIMATE)
call fftw_f77_one(plan,in,out)
call fftw_f77_destroy_plan(plan)
Notice how all routines are called as Fortran subroutines, and the
plan is returned via the first argument to `fftw_f77_create_plan'.
*Important:* these examples assume that `integer' is the same size as a
pointer, and may need modification on a 64bit machine. *Note Wrapper
Routines::, above. To do the same thing, but using 8 threads in
parallel (*note Multithreaded FFTW::.), you would simply replace the
call to `fftw_f77_one' with:
call fftw_f77_threads_one(8,plan,in,out)
To transform a threedimensional array inplace with C, you might do:
fftw_complex arr[L][M][N];
fftwnd_plan plan;
int n[3] = {L,M,N};
plan = fftwnd_create_plan(3,n,FFTW_FORWARD,
FFTW_ESTIMATE  FFTW_IN_PLACE);
fftwnd_one(plan, arr, 0);
fftwnd_destroy_plan(plan);
In Fortran, you would use this instead:
double complex arr
dimension arr(L,M,N)
integer n
dimension n(3)
integer plan
n(1) = L
n(2) = M
n(3) = N
call fftwnd_f77_create_plan(plan,3,n,FFTW_FORWARD,
+ FFTW_ESTIMATE + FFTW_IN_PLACE)
call fftwnd_f77_one(plan, arr, 0)
call fftwnd_f77_destroy_plan(plan)
Instead of calling `fftwnd_f77_create_plan(plan,3,n,...)', we could
also have called `fftw3d_f77_create_plan(plan,L,M,N,...)'.
Note that we pass the array dimensions in the "natural" order; also
note that the last argument to `fftwnd_f77' is ignored since the
transform is `FFTW_IN_PLACE'.
To transform a onedimensional real array in Fortran, you might do:
double precision in, out
dimension in(N), out(N)
integer plan
call rfftw_f77_create_plan(plan,N,FFTW_REAL_TO_COMPLEX,
+ FFTW_ESTIMATE)
call rfftw_f77_one(plan,in,out)
call rfftw_f77_destroy_plan(plan)
To transform a twodimensional real array, out of place, you might
use the following:
double precision in
double complex out
dimension in(M,N), out(M/2 + 1, N)
integer plan
call rfftw2d_f77_create_plan(plan,M,N,FFTW_REAL_TO_COMPLEX,
+ FFTW_ESTIMATE)
call rfftwnd_f77_one_real_to_complex(plan, in, out)
call rfftwnd_f77_destroy_plan(plan)
Important: Notice that it is the *first* 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 wrapper routines
reversing the order of the array dimensions passed to FFTW so that the
Fortran program can use its ordinary columnmajor order.
File: fftw.info, Node: Installation and Customization, Next: Acknowledgments, Prev: Calling FFTW from Fortran, Up: Top
Installation and Customization
******************************
This chapter describes the installation and customization of FFTW,
the latest version of which may be downloaded from the FFTW home page (http://www.fftw.org).
As distributed, FFTW makes very few assumptions about your system.
All you need is an ANSI C compiler (`gcc' is fine, although
vendorprovided compilers often produce faster code). However,
installation of FFTW is somewhat simpler if you have a Unix or a GNU
system, such as Linux. In this chapter, we first describe the
installation of FFTW on Unix and nonUnix systems. We then describe how
you can customize FFTW to achieve better performance. Specifically, you
can I) enable `gcc'/x86specific hacks that improve performance on
Pentia and PentiumPro's; II) adapt FFTW to use the highresolution clock
of your machine, if any; III) produce code (*codelets*) to support fast
transforms of sizes that are not supported efficiently by the standard
FFTW distribution.
* Menu:
* Installation on Unix::
* Installation on nonUnix Systems::
* Installing FFTW in both single and double precision::
* gcc and Pentium hacks::
* Customizing the timer::
* Generating your own code::
File: fftw.info, Node: Installation on Unix, Next: Installation on nonUnix Systems, Prev: Installation and Customization, Up: Installation and Customization
Installation on Unix
====================
FFTW comes with a `configure' program in the GNU style.
Installation can be as simple as:
./configure
make
make install
This will build the uniprocessor complex and real transform libraries
along with the test programs. We strongly recommend that you use GNU
`make' if it is available; on some systems it is called `gmake'. The
"`make install'" command installs the fftw and rfftw libraries in
standard places, and typically requires root privileges (unless you
specify a different install directory with the `prefix' flag to
`configure'). You can also type "`make check'" to put the FFTW test
programs through their paces. If you have problems during
configuration or compilation, you may want to run "`make distclean'"
before trying again; this ensures that you don't have any stale files
left over from previous compilation attempts.
The `configure' script knows good `CFLAGS' (C compiler flags) for a
few systems. If your system is not known, the `configure' script will
print out a warning. (1) In this case, you can compile FFTW with the
command
make CFLAGS=""
If you do find an optimal set of `CFLAGS' for your system, please
let us know what they are (along with the output of `config.guess') so
that we can include them in future releases.
The `configure' program supports all the standard flags defined by
the GNU Coding Standards; see the `INSTALL' file in FFTW or
the GNU web page (http://www.gnu.org/prep/standards_toc.html). Note
especially `help' to list all flags and `enableshared' to create
shared, rather than static, libraries. `configure' also accepts a few
FFTWspecific flags, particularly:
* `enablefloat' Produces a singleprecision version of FFTW
(`float') instead of the default doubleprecision (`double').
*Note Installing FFTW in both single and double precision::.
* `enabletypeprefix' Adds a `d' or `s' prefix to all installed
libraries and header files to indicate the floatingpoint
precision. *Note Installing FFTW in both single and double
precision::. (`enabletypeprefix=' lets you add an
arbitrary prefix.) By default, no prefix is used.
* `enablethreads' Enables compilation and installation of the FFTW
threads library (*note Multithreaded FFTW::.), which provides a
simple interface to parallel transforms for SMP systems. (By
default, the threads routines are not compiled.)
* `enablempi' Enables compilation and installation of the FFTW MPI
library (*note MPI FFTW::.), which provides parallel transforms for
distributedmemory systems with MPI. (By default, the MPI
routines are not compiled.)
* `disablefortran' Disables inclusion of Fortrancallable wrapper
routines (*note Calling FFTW from Fortran::.) 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 `configure' script finds a Fortran compiler on your system.
* `withgcc' Enables the use of `gcc'. By default, FFTW uses the
vendorsupplied `cc' compiler if present. Unfortunately, `gcc'
produces slower code than `cc' on many systems.
* `enablei386hacks' *Note gcc and Pentium hacks::, below.
* `enablepentiumtimer' *Note gcc and Pentium hacks::, below.
To force `configure' to use a particular C compiler (instead of the
default, usually `cc'), set the environment variable `CC' to the name
of the desired compiler before running `configure'; you may also need
to set the flags via the variable `CFLAGS'.
 Footnotes 
(1) Each version of `cc' seems to have its own magic incantation to
get the fastest code most of the timeyou'd think that people would
have agreed upon some convention, e.g. "`Omax'", by now.
File: fftw.info, Node: Installation on nonUnix Systems, Next: Installing FFTW in both single and double precision, Prev: Installation on Unix, Up: Installation and Customization
Installation on nonUnix Systems
================================
It is quite straightforward to install FFTW even on nonUnix systems
lacking the niceties of the `configure' script. The FFTW Home Page may
include some FFTW packages preconfigured for particular
systems/compilers, and also contains installation notes sent in by
users. All you really need to do, though, is to compile all of the
`.c' files in the appropriate directories of the FFTW package. (You
needn't worry about the many extraneous files lying around.)
For the complex transforms, compile all of the `.c' files in the
`fftw' directory and link them into a library. Similarly, for the real
transforms, compile all of the `.c' files in the `rfftw' directory into
a library. Note that these sources `#include' various files in the
`fftw' and `rfftw' directories, so you may need to set up the
`#include' paths for your compiler appropriately. Be sure to enable
the highestpossible level of optimization in your compiler.
By default, FFTW is compiled for doubleprecision transforms. To
work in single precision rather than double precision, `#define' the
symbol `FFTW_ENABLE_FLOAT' in `fftw.h' (in the `fftw' directory) and
(re)compile FFTW.
These libraries should be linked with any program that uses the
corresponding transforms. The required header files, `fftw.h' and
`rfftw.h', are located in the `fftw' and `rfftw' directories
respectively; you may want to put them with the libraries, or wherever
header files normally go on your system.
FFTW includes test programs, `fftw_test' and `rfftw_test', in the
`tests' directory. These are compiled and linked like any program
using FFTW, except that they use additional header files located in the
`fftw' and `rfftw' directories, so you will need to set your compiler
`#include' paths appropriately. `fftw_test' is compiled from
`fftw_test.c' and `test_main.c', while `rfftw_test' is compiled from
`rfftw_test.c' and `test_main.c'. When you run these programs, you
will be prompted interactively for various possible tests to perform;
see also `tests/README' for more information.
File: fftw.info, Node: Installing FFTW in both single and double precision, Next: gcc and Pentium hacks, Prev: Installation on nonUnix Systems, Up: Installation and Customization
Installing FFTW in both single and double precision
===================================================
It is often useful to install both single and doubleprecision
versions of the FFTW libraries on the same machine, and we provide a
convenient mechanism for achieving this on Unix systems.
When the `enabletypeprefix' option of configure is used, the
FFTW libraries and header files are installed with a prefix of `d' or
`s', depending upon whether you compiled in double or single precision.
Then, instead of linking your program with `lrfftw lfftw', for
example, you would link with `ldrfftw ldfftw' to use the
doubleprecision version or with `lsrfftw lsfftw' to use the
singleprecision version. Also, you would `#include' `' or
`' instead of `', and so on.
*The names of FFTW functions, data types, and constants remain
unchanged!* You still call, for instance, `fftw_one' and not
`dfftw_one'. Only the names of header files and libraries are
modified. One consequence of this is that *you cannot use both the
single and doubleprecision FFTW libraries in the same program,
simultaneously,* as the function names would conflict.
So, to install both the single and doubleprecision libraries on the
same machine, you would do:
./configure enabletypeprefix [ other options ]
make
make install
make clean
./configure enablefloat enabletypeprefix [ other options ]
make
make install
File: fftw.info, Node: gcc and Pentium hacks, Next: Customizing the timer, Prev: Installing FFTW in both single and double precision, Up: Installation and Customization
`gcc' and Pentium hacks
=======================
The `configure' option `enablei386hacks' enables specific
optimizations for the Pentium and later x86 CPUs under gcc, which can
significantly improve performance of doubleprecision transforms.
Specifically, we have tested these hacks on Linux with `gcc' 2.[789]
and versions of `egcs' since 1.0.3. These optimizations affect only
the performance and not the correctness of FFTW (i.e. it is always safe
to try them out).
These hacks provide a workaround to the incorrect alignment of local
`double' variables in `gcc'. The compiler aligns these variables to
multiples of 4 bytes, but execution is much faster (on Pentium and
PentiumPro) if `double's are aligned to a multiple of 8 bytes. By
carefully counting the number of variables allocated by the compiler in
performancecritical regions of the code, we have been able to
introduce dummy allocations (using `alloca') that align the stack
properly. The hack depends crucially on the compiler flags that are
used. For example, it won't work without `fomitframepointer'.
In principle, these hacks are no longer required under `gcc'
versions 2.95 and later, which automatically align the stack correctly
(see `mpreferredstackboundary' in the `gcc' manual). However, we
have encountered a
bug (http://egcs.cygnus.com/ml/gccbugs/199911/msg00259.html) in the
stack alignment of versions 2.95.[012] that causes FFTW's stack to be
misaligned under some circumstances. The `configure' script
automatically detects this bug and disables `gcc''s stack alignment in
favor of our own hacks when `enablei386hacks' is used.
The `fftw_test' program outputs speed measurements that you can use
to see if these hacks are beneficial.
The `configure' option `enablepentiumtimer' enables the use of
the Pentium and PentiumPro cycle counter for timing purposes. In order
to get correct results, you must define `FFTW_CYCLES_PER_SEC' in
`fftw/config.h' to be the clock speed of your processor; the resulting
FFTW library will be nonportable. The use of this option is
deprecated. On serious operating systems (such as Linux), FFTW uses
`gettimeofday()', which has enough resolution and is portable. (Note
that Win32 has its own highresolution timing routines as well. FFTW
contains unsupported code to use these routines.)
File: fftw.info, Node: Customizing the timer, Next: Generating your own code, Prev: gcc and Pentium hacks, Up: Installation and Customization
Customizing the timer
=====================
FFTW needs a reasonablyprecise clock in order to find the optimal
way to compute a transform. On Unix systems, `configure' looks for
`gettimeofday' and other systemspecific timers. If it does not find
any high resolution clock, it defaults to using the `clock()' function,
which is very portable, but forces FFTW to run for a long time in order
to get reliable measurements.
If your machine supports a highresolution clock not recognized by
FFTW, it is therefore advisable to use it. You must edit
`fftw/fftwint.h'. There are a few macros you must redefine. The code
is documented and should be selfexplanatory. (By the way, `fftwint'
stands for `fftwinternal', but for some inexplicable reason people are
still using primitive systems with 8.3 filenames.)
Even if you don't install highresolution timing code, we still
recommend that you look at the `FFTW_TIME_MIN' constant in
`fftw/fftwint.h'. This constant holds the minimum time interval (in
seconds) required to get accurate timing measurements, and should be (at
least) several hundred times the resolution of your clock. The default
constants are on the conservative side, and may cause FFTW to take
longer than necessary when you create a plan. Set `FFTW_TIME_MIN' to
whatever is appropriate on your system (be sure to set the *right*
`FFTW_TIME_MIN'...there are several definitions in `fftwint.h',
corresponding to different platforms and timers).
As an aid in checking the resolution of your clock, you can use the
`tests/fftw_test' program with the `t' option (c.f. `tests/README').
Remember, the mere fact that your clock reports times in, say,
picoseconds, does not mean that it is actually *accurate* to that
resolution.
File: fftw.info, Node: Generating your own code, Prev: Customizing the timer, Up: Installation and Customization
Generating your own code
========================
If you know that you will only use transforms of a certain size (say,
powers of 2) and want to reduce the size of the library, you can
reconfigure FFTW to support only those sizes you are interested in. You
may even generate code to enable efficient transforms of a size not
supported by the default distribution. The default distribution
supports transforms of any size, but not all sizes are equally fast.
The default installation of FFTW is best at handling sizes of the form
2^a 3^b 5^c 7^d 11^e 13^f, where e+f is either 0 or 1, and the other
exponents are arbitrary. Other sizes are computed by means of a slow,
generalpurpose routine. However, if you have an application that
requires fast transforms of size, say, `17', there is a way to generate
specialized code to handle that.
The directory `gensrc' contains all the programs and scripts that
were used to generate FFTW. In particular, the program
`gensrc/genfft.ml' was used to generate the code that FFTW uses to
compute the transforms. We do not expect casual users to use it.
`genfft' is a rather sophisticated program that generates directed
acyclic graphs of FFT algorithms and performs algebraic simplifications
on them. `genfft' is written in Objective Caml, a dialect of ML.
Objective Caml is described at `http://pauillac.inria.fr/ocaml/' and
can be downloaded from from `ftp://ftp.inria.fr/lang/camllight'.
If you have Objective Caml installed, you can type `sh bootstrap.sh'
in the toplevel directory to regenerate the files. If you change the
`gensrc/config' file, you can optimize FFTW for sizes that are not
currently supported efficiently (say, 17 or 19).
We do not provide more details about the codegeneration process,
since we do not expect that users will need to generate their own code.
However, feel free to contact us at if you are
interested in the subject.
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
objectoriented programming are the latest advancement in the field.
The internal operation of the codelet generator is described in the
paper, "A Fast Fourier Transform Compiler," by M. Frigo, which is
available from the FFTW home page (http://www.fftw.org) and will appear
in the `Proceedings of the 1999 ACM SIGPLAN Conference on Programming
Language Design and Implementation (PLDI)'.
File: fftw.info, Node: Acknowledgments, Next: License and Copyright, Prev: Installation and Customization, Up: Top
Acknowledgments
***************
Matteo Frigo was supported in part by the Defense Advanced Research
Projects Agency (DARPA) under Grants N000149410985 and
F306029710270, and by a Digital Equipment Corporation Fellowship.
Steven G. Johnson was supported in part by a DoD 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 DMR9400334.
Both authors were also supported in part by their respective
girlfriends, by the letters "Q" and "R", and by the number 12.
We are grateful to SUN Microsystems Inc. for its donation of a
cluster of 9 8processor Ultra HPC 5000 SMPs (24 Gflops peak). These
machines served as the primary platform for the development of earlier
versions of FFTW.
We thank Intel Corporation for donating a fourprocessor Pentium Pro
machine. We thank the Linux community for giving us a decent OS to run
on that machine.
The `genfft' program 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 `ftp.inria.fr' in the
directory `lang/camllight'. We used versions 1.07 and 2.00 of the
software. In previous releases of FFTW, `genfft' was written in Caml
Light, by the same authors. An even earlier implementation of `genfft'
was written in Scheme, but Caml is definitely better for this kind of
application.
FFTW uses many tools from the GNU project, including `automake',
`texinfo', and `libtool'.
Prof. Charles E. Leiserson of MIT provided continuous support and
encouragement. This program would not exist without him. Charles also
proposed the name "codelets" for the basic FFT blocks.
Prof. John D. Joannopoulos of MIT demonstrated continuing tolerance
of Steven's "extracurricular" computerscience activities. Steven's
chances at a physics degree would not exist without him.
Andrew Sterian contributed the Windows timing code.
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.
Wolfgang Reimer contributed the Pentium cycle counter and a few fixes
that help portability.
MingChang Liu uncovered a wellhidden bug in the complex transforms
of FFTW 2.0 and supplied a patch to correct it.
The FFTW FAQ was written in `bfnn' (Bizarre Format With No Name) and
formatted using the tools developed by Ian Jackson for the Linux FAQ.
*We are especially thankful to all of our users for their continuing
support, feedback, and interest during our development of FFTW.*
File: fftw.info, Node: License and Copyright, Next: Concept Index, Prev: Acknowledgments, Up: Top
License and Copyright
*********************
FFTW is copyright (C) 19971999 Massachusetts Institute of
Technology.
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 021111307 USA. You can
also find the GPL on the GNU web site (http://www.gnu.org/copyleft/gpl.html).
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
*required* to do so; it is up to your common sense to decide whether
you want to comply with this request or not.)
Nonfree versions of FFTW are available under terms different than
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 alternate terms you must purchase a license from MIT's Technology
Licensing Office. Users interested in such a license should contact us
() for more information.
File: fftw.info, Node: Concept Index, Next: Library Index, Prev: License and Copyright, Up: Top
Concept Index
*************
* Menu:
* algorithm: Introduction.
* benchfft: Introduction.
* benchmark <1>: gcc and Pentium hacks.
* benchmark <2>: MPI Tips.
* benchmark <3>: How Many Threads to Use?.
* benchmark: Introduction.
* blocking: Usage of MPI FFTW for Complex Multidimensional Transforms.
* C multidimensional arrays: Static Arrays in C.
* Caml <1>: Acknowledgments.
* Caml: Generating your own code.
* Cilk <1>: Parallel FFTW.
* Cilk: Introduction.
* clock: Customizing the timer.
* code generator <1>: Generating your own code.
* code generator: Introduction.
* columnmajor <1>: Fortran Examples.
* columnmajor <2>: Wrapper Routines.
* columnmajor: Columnmajor Format.
* compiler <1>: gcc and Pentium hacks.
* compiler <2>: Installation on nonUnix Systems.
* compiler <3>: Installation on Unix.
* compiler <4>: Installation and Customization.
* compiler <5>: Calling FFTW from Fortran.
* compiler: Introduction.
* compiler flags: Installation on Unix.
* complex multidimensional transform <1>: Multidimensional Transforms Reference.
* complex multidimensional transform: Complex Multidimensional Transforms Tutorial.
* complex number: Data Types.
* complex onedimensional transform: Complex Onedimensional Transforms Tutorial.
* complex to real transform <1>: Real Onedimensional Transforms Reference.
* complex to real transform: Real Onedimensional Transforms Tutorial.
* complex transform: Complex Onedimensional Transforms Tutorial.
* configure <1>: Installing FFTW in both single and double precision.
* configure <2>: Installation on Unix.
* configure <3>: MPI FFTW Installation.
* configure <4>: Installation and Supported Hardware/Software.
* configure: Data Types.
* convolution: Real Multidimensional Transforms Tutorial.
* cyclic convolution: Real Multidimensional Transforms Tutorial.
* Discrete Fourier Transform <1>: What RFFTWND Really Computes.
* Discrete Fourier Transform <2>: What RFFTW Really Computes.
* Discrete Fourier Transform <3>: What FFTWND Really Computes.
* Discrete Fourier Transform: What FFTW Really Computes.
* distributed array format <1>: Usage of MPI FFTW for Complex Onedimensional Transforms.
* distributed array format <2>: Usage of MPI FFTW for Real Multidimensional Transforms.
* distributed array format: MPI Data Layout.
* distributed memory <1>: MPI Data Layout.
* distributed memory <2>: MPI FFTW.
* distributed memory: Parallel FFTW.
* Ecclesiastes: Caveats in Using Wisdom.
* executor: Introduction.
* FFTW: Introduction.
* FFTWND: Multidimensional Transforms Reference.
* flags <1>: FFTW Constants in Fortran.
* flags <2>: Usage of MPI FFTW for Complex Onedimensional Transforms.
* flags <3>: rfftwnd_create_plan.
* flags <4>: rfftw_create_plan.
* flags <5>: fftwnd_create_plan.
* flags <6>: fftw_create_plan.
* flags <7>: Complex Multidimensional Transforms Tutorial.
* flags: Complex Onedimensional Transforms Tutorial.
* floatingpoint precision <1>: Installing FFTW in both single and double precision.
* floatingpoint precision <2>: Installation on nonUnix Systems.
* floatingpoint precision <3>: Installation on Unix.
* floatingpoint precision <4>: Wrapper Routines.
* floatingpoint precision: Data Types.
* Fortrancallable wrappers <1>: Installation on Unix.
* Fortrancallable wrappers <2>: Calling FFTW from Fortran.
* Fortrancallable wrappers: Columnmajor Format.
* frequency <1>: What FFTW Really Computes.
* frequency <2>: Complex Multidimensional Transforms Tutorial.
* frequency: Complex Onedimensional Transforms Tutorial.
* gettimeofday: Customizing the timer.
* girlfriends: Acknowledgments.
* halfcomplex array <1>: Data Types.
* halfcomplex array: Real Onedimensional Transforms Tutorial.
* hermitian array <1>: What RFFTWND Really Computes.
* hermitian array: Data Types.
* inplace transform <1>: Wrapper Routines.
* inplace transform <2>: Usage of MPI FFTW for Complex Multidimensional Transforms.
* inplace transform <3>: Tips for Optimal Threading.
* inplace transform <4>: Array Dimensions for Real Multidimensional Transforms.
* inplace transform <5>: rfftwnd_create_plan.
* inplace transform <6>: fftwnd.
* inplace transform <7>: fftw.
* inplace transform <8>: fftw_create_plan.
* inplace transform: Complex Multidimensional Transforms Tutorial.
* installation: Installation and Customization.
* linking on Unix <1>: Usage of MPI FFTW for Complex Onedimensional Transforms.
* linking on Unix <2>: Usage of MPI FFTW for Real Multidimensional Transforms.
* linking on Unix <3>: Usage of MPI FFTW for Complex Multidimensional Transforms.
* linking on Unix <4>: Usage of Multithreaded FFTW.
* linking on Unix <5>: Real Onedimensional Transforms Tutorial.
* linking on Unix: Complex Onedimensional Transforms Tutorial.
* LISP <1>: Acknowledgments.
* LISP: Importing and Exporting Wisdom.
* loadbalancing: MPI Tips.
* malloc <1>: Memory Allocator Reference.
* malloc: Dynamic Arrays in C.
* ML: Generating your own code.
* monadic programming: Generating your own code.
* MPI <1>: Installation on Unix.
* MPI <2>: MPI FFTW.
* MPI <3>: Parallel FFTW.
* MPI: Introduction.
* MPI_Alltoall <1>: Usage of MPI FFTW for Complex Onedimensional Transforms.
* MPI_Alltoall <2>: Usage of MPI FFTW for Complex Multidimensional Transforms.
* MPI_Alltoall: MPI FFTW Installation.
* MPI_Barrier: Usage of MPI FFTW for Complex Multidimensional Transforms.
* MPI_COMM_WORLD <1>: Usage of MPI FFTW for Complex Onedimensional Transforms.
* MPI_COMM_WORLD: Usage of MPI FFTW for Complex Multidimensional Transforms.
* MPI_Finalize: Usage of MPI FFTW for Complex Multidimensional Transforms.
* MPI_Init: Usage of MPI FFTW for Complex Multidimensional Transforms.
* multidimensional transform <1>: Real Multidimensional Transforms Reference.
* multidimensional transform <2>: Multidimensional Transforms Reference.
* multidimensional transform: Complex Multidimensional Transforms Tutorial.
* n_fields <1>: Usage of MPI FFTW for Complex Onedimensional Transforms.
* n_fields: Usage of MPI FFTW for Complex Multidimensional Transforms.
* nerdreadable text: Importing and Exporting Wisdom.
* normalization <1>: Usage of MPI FFTW for Complex Multidimensional Transforms.
* normalization <2>: What RFFTW Really Computes.
* normalization <3>: What FFTW Really Computes.
* normalization <4>: Real Multidimensional Transforms Tutorial.
* normalization <5>: Real Onedimensional Transforms Tutorial.
* normalization <6>: Complex Multidimensional Transforms Tutorial.
* normalization: Complex Onedimensional Transforms Tutorial.
* number of threads <1>: How Many Threads to Use?.
* number of threads: Usage of Multithreaded FFTW.
* outofplace transform: Complex Multidimensional Transforms Tutorial.
* padding <1>: Usage of MPI FFTW for Real Multidimensional Transforms.
* padding <2>: Array Dimensions for Real Multidimensional Transforms.
* padding: Real Multidimensional Transforms Tutorial.
* parallel transform <1>: Parallel FFTW.
* parallel transform: Introduction.
* Pentium hack: gcc and Pentium hacks.
* plan <1>: Usage of MPI FFTW for Complex Multidimensional Transforms.
* plan <2>: Complex Onedimensional Transforms Tutorial.
* plan: Introduction.
* planner: Introduction.
* power spectrum: Real Onedimensional Transforms Tutorial.
* rank: Complex Multidimensional Transforms Tutorial.
* real multidimensional transform <1>: Real Multidimensional Transforms Reference.
* real multidimensional transform: Real Multidimensional Transforms Tutorial.
* real number: Data Types.
* real transform <1>: Real Onedimensional Transforms Reference.
* real transform: Real Onedimensional Transforms Tutorial.
* RFFTW <1>: Real Onedimensional Transforms Reference.
* RFFTW: Real Onedimensional Transforms Tutorial.
* RFFTWND: Real Multidimensional Transforms Reference.
* rfftwnd array format <1>: Fortran Examples.
* rfftwnd array format <2>: Usage of MPI FFTW for Real Multidimensional Transforms.
* rfftwnd array format <3>: Strides in Inplace RFFTWND.
* rfftwnd array format <4>: Array Dimensions for Real Multidimensional Transforms.
* rfftwnd array format: Real Multidimensional Transforms Tutorial.
* rowmajor <1>: MPI Data Layout.
* rowmajor <2>: fftwnd_create_plan.
* rowmajor <3>: Rowmajor Format.
* rowmajor: Real Multidimensional Transforms Tutorial.
* saving plans to disk: Words of Wisdom.
* slab decomposition: MPI Data Layout.
* specific planner: Discussion on Specific Plans.
* stride <1>: Usage of MPI FFTW for Complex Multidimensional Transforms.
* stride <2>: Strides in Inplace RFFTWND.
* stride <3>: rfftwnd.
* stride <4>: rfftw.
* stride <5>: fftwnd.
* stride <6>: fftw.
* stride: Rowmajor Format.
* thread safety <1>: Using Multithreaded FFTW in a Multithreaded Program.
* thread safety: Thread safety.
* threads <1>: Installation on Unix.
* threads <2>: Multithreaded FFTW.
* threads <3>: Parallel FFTW.
* threads <4>: Thread safety.
* threads: Introduction.
* timer, customization of: Customizing the timer.
* Tutorial: Tutorial.
* wisdom <1>: Wisdom Reference.
* wisdom <2>: rfftwnd_create_plan.
* wisdom <3>: fftwnd_create_plan.
* wisdom <4>: fftw_create_plan.
* wisdom: Words of Wisdom.
* wisdom, import and export: Importing and Exporting Wisdom.
* wisdom, problems with: Caveats in Using Wisdom.
linuxx86_64/info/fftw.info50000644003427200235140000002760010015476203014363 0ustar jimnamdThis is Info file fftw.info, produced by Makeinfo version 1.68 from the
input file fftw.texi.
This is the FFTW User's manual.
Copyright (C) 19971999 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.
File: fftw.info, Node: Library Index, Prev: Concept Index, Up: Top
Library Index
*************
* Menu:
* fftw: fftw.
* fftw2d_create_plan <1>: fftwnd_create_plan.
* fftw2d_create_plan: Complex Multidimensional Transforms Tutorial.
* fftw2d_create_plan_specific: fftwnd_create_plan.
* fftw2d_mpi_create_plan: Usage of MPI FFTW for Complex Multidimensional Transforms.
* fftw3d_create_plan <1>: fftwnd_create_plan.
* fftw3d_create_plan: Complex Multidimensional Transforms Tutorial.
* fftw3d_create_plan_specific: fftwnd_create_plan.
* fftw3d_f77_create_plan: Fortran Examples.
* fftw3d_mpi_create_plan: Usage of MPI FFTW for Complex Multidimensional Transforms.
* FFTW_BACKWARD: Complex Onedimensional Transforms Tutorial.
* FFTW_COMPLEX: Data Types.
* fftw_complex <1>: Data Types.
* fftw_complex: Complex Onedimensional Transforms Tutorial.
* FFTW_COMPLEX_TO_REAL <1>: Usage of MPI FFTW for Real Multidimensional Transforms.
* FFTW_COMPLEX_TO_REAL <2>: rfftw_create_plan.
* FFTW_COMPLEX_TO_REAL: Real Onedimensional Transforms Tutorial.
* fftw_create_plan <1>: fftw_create_plan.
* fftw_create_plan: Complex Onedimensional Transforms Tutorial.
* fftw_create_plan_specific: fftw_create_plan.
* fftw_destroy_plan <1>: fftw_destroy_plan.
* fftw_destroy_plan: Complex Onedimensional Transforms Tutorial.
* fftw_direction <1>: rfftwnd_create_plan.
* fftw_direction <2>: fftwnd_create_plan.
* fftw_direction <3>: fftw_create_plan.
* fftw_direction <4>: Real Onedimensional Transforms Tutorial.
* fftw_direction <5>: Complex Multidimensional Transforms Tutorial.
* fftw_direction: Complex Onedimensional Transforms Tutorial.
* FFTW_ENABLE_FLOAT: Data Types.
* FFTW_ESTIMATE: Complex Onedimensional Transforms Tutorial.
* fftw_export_wisdom <1>: fftw_export_wisdom.
* fftw_export_wisdom: Words of Wisdom.
* fftw_export_wisdom_to_file <1>: fftw_export_wisdom.
* fftw_export_wisdom_to_file: Importing and Exporting Wisdom.
* fftw_export_wisdom_to_string <1>: fftw_export_wisdom.
* fftw_export_wisdom_to_string: Importing and Exporting Wisdom.
* fftw_f77_create_plan: Fortran Examples.
* fftw_f77_destroy_plan: Fortran Examples.
* fftw_f77_one <1>: Fortran Examples.
* fftw_f77_one: Wrapper Routines.
* fftw_f77_threads_one: Fortran Examples.
* fftw_forget_wisdom: fftw_forget_wisdom.
* FFTW_FORWARD: Complex Onedimensional Transforms Tutorial.
* fftw_free_hook: Memory Allocator Reference.
* fftw_import_wisdom <1>: fftw_import_wisdom.
* fftw_import_wisdom: Words of Wisdom.
* fftw_import_wisdom_from_file <1>: fftw_import_wisdom.
* fftw_import_wisdom_from_file: Importing and Exporting Wisdom.
* fftw_import_wisdom_from_string <1>: fftw_import_wisdom.
* fftw_import_wisdom_from_string: Importing and Exporting Wisdom.
* FFTW_IN_PLACE: Complex Multidimensional Transforms Tutorial.
* fftw_malloc: Memory Allocator Reference.
* fftw_malloc_hook: Memory Allocator Reference.
* FFTW_MEASURE: Complex Onedimensional Transforms Tutorial.
* fftw_mpi: Usage of MPI FFTW for Complex Onedimensional Transforms.
* fftw_mpi_create_plan: Usage of MPI FFTW for Complex Onedimensional Transforms.
* fftw_mpi_destroy_plan: Usage of MPI FFTW for Complex Onedimensional Transforms.
* fftw_mpi_local_sizes: Usage of MPI FFTW for Complex Onedimensional Transforms.
* fftw_mpi_plan: Usage of MPI FFTW for Complex Onedimensional Transforms.
* fftw_mpi_test <1>: MPI Tips.
* fftw_mpi_test: MPI FFTW Installation.
* FFTW_NORMAL_ORDER: Usage of MPI FFTW for Complex Multidimensional Transforms.
* fftw_one <1>: fftw.
* fftw_one: Complex Onedimensional Transforms Tutorial.
* FFTW_OUT_OF_PLACE: fftw_create_plan.
* fftw_plan <1>: fftw_create_plan.
* fftw_plan: Complex Onedimensional Transforms Tutorial.
* FFTW_REAL: Data Types.
* fftw_real: Data Types.
* FFTW_REAL_TO_COMPLEX <1>: rfftw_create_plan.
* FFTW_REAL_TO_COMPLEX: Real Onedimensional Transforms Tutorial.
* FFTW_SCRAMBLED_INPUT: Usage of MPI FFTW for Complex Onedimensional Transforms.
* FFTW_SCRAMBLED_OUTPUT: Usage of MPI FFTW for Complex Onedimensional Transforms.
* fftw_test <1>: gcc and Pentium hacks.
* fftw_test: Installation on nonUnix Systems.
* fftw_threads: Usage of Multithreaded FFTW.
* fftw_threads_init: Usage of Multithreaded FFTW.
* fftw_threads_one: Usage of Multithreaded FFTW.
* fftw_threads_test: How Many Threads to Use?.
* FFTW_THREADSAFE: Thread safety.
* FFTW_TIME_MIN: Customizing the timer.
* FFTW_TRANSPOSED_ORDER <1>: MPI Tips.
* FFTW_TRANSPOSED_ORDER <2>: Usage of MPI FFTW for Real Multidimensional Transforms.
* FFTW_TRANSPOSED_ORDER <3>: MPI Data Layout.
* FFTW_TRANSPOSED_ORDER: Usage of MPI FFTW for Complex Multidimensional Transforms.
* FFTW_USE_WISDOM: Words of Wisdom.
* fftwnd <1>: fftwnd.
* fftwnd: Complex Multidimensional Transforms Tutorial.
* fftwnd_create_plan <1>: fftwnd_create_plan.
* fftwnd_create_plan: Complex Multidimensional Transforms Tutorial.
* fftwnd_create_plan_specific: fftwnd_create_plan.
* fftwnd_destroy_plan <1>: fftwnd_destroy_plan.
* fftwnd_destroy_plan: Complex Multidimensional Transforms Tutorial.
* fftwnd_f77_create_plan: Fortran Examples.
* fftwnd_f77_destroy_plan: Fortran Examples.
* fftwnd_f77_one: Fortran Examples.
* fftwnd_mpi: Usage of MPI FFTW for Complex Multidimensional Transforms.
* fftwnd_mpi_create_plan: Usage of MPI FFTW for Complex Multidimensional Transforms.
* fftwnd_mpi_destroy_plan: Usage of MPI FFTW for Complex Multidimensional Transforms.
* fftwnd_mpi_local_sizes: MPI Data Layout.
* fftwnd_mpi_plan: Usage of MPI FFTW for Complex Multidimensional Transforms.
* fftwnd_one <1>: fftwnd.
* fftwnd_one: Complex Multidimensional Transforms Tutorial.
* fftwnd_plan <1>: fftwnd_create_plan.
* fftwnd_plan: Complex Multidimensional Transforms Tutorial.
* fftwnd_threads: Usage of Multithreaded FFTW.
* fftwnd_threads_one: Usage of Multithreaded FFTW.
* genfft <1>: Acknowledgments.
* genfft: Generating your own code.
* rfftw: rfftw.
* rfftw2d_create_plan <1>: Usage of MPI FFTW for Real Multidimensional Transforms.
* rfftw2d_create_plan <2>: rfftwnd_create_plan.
* rfftw2d_create_plan: Real Multidimensional Transforms Tutorial.
* rfftw2d_f77_create_plan: Fortran Examples.
* rfftw3d_create_plan <1>: rfftwnd_create_plan.
* rfftw3d_create_plan: Real Multidimensional Transforms Tutorial.
* rfftw3d_mpi_create_plan: Usage of MPI FFTW for Real Multidimensional Transforms.
* rfftw_create_plan <1>: rfftw_create_plan.
* rfftw_create_plan: Real Onedimensional Transforms Tutorial.
* rfftw_create_plan_specific: rfftw_create_plan.
* rfftw_destroy_plan <1>: rfftw_destroy_plan.
* rfftw_destroy_plan: Real Onedimensional Transforms Tutorial.
* rfftw_f77_create_plan: Fortran Examples.
* rfftw_f77_destroy_plan: Fortran Examples.
* rfftw_f77_one: Fortran Examples.
* rfftw_mpi_test <1>: MPI Tips.
* rfftw_mpi_test: MPI FFTW Installation.
* rfftw_one <1>: rfftw.
* rfftw_one: Real Onedimensional Transforms Tutorial.
* rfftw_plan <1>: rfftw_create_plan.
* rfftw_plan: Real Onedimensional Transforms Tutorial.
* rfftw_test: Installation on nonUnix Systems.
* rfftw_threads: Usage of Multithreaded FFTW.
* rfftw_threads_one: Usage of Multithreaded FFTW.
* rfftw_threads_test: How Many Threads to Use?.
* rfftwnd_complex_to_real: rfftwnd.
* rfftwnd_create_plan <1>: Usage of MPI FFTW for Real Multidimensional Transforms.
* rfftwnd_create_plan <2>: rfftwnd_create_plan.
* rfftwnd_create_plan: Real Multidimensional Transforms Tutorial.
* rfftwnd_destroy_plan: rfftwnd_destroy_plan.
* rfftwnd_f77_destroy_plan: Fortran Examples.
* rfftwnd_f77_one_real_to_complex: Fortran Examples.
* rfftwnd_mpi: Usage of MPI FFTW for Real Multidimensional Transforms.
* rfftwnd_mpi_destroy_plan: Usage of MPI FFTW for Real Multidimensional Transforms.
* rfftwnd_mpi_local_sizes: Usage of MPI FFTW for Real Multidimensional Transforms.
* rfftwnd_one_complex_to_real <1>: rfftwnd.
* rfftwnd_one_complex_to_real: Real Multidimensional Transforms Tutorial.
* rfftwnd_one_real_to_complex <1>: rfftwnd.
* rfftwnd_one_real_to_complex: Real Multidimensional Transforms Tutorial.
* rfftwnd_plan <1>: rfftwnd_create_plan.
* rfftwnd_plan: Real Multidimensional Transforms Tutorial.
* rfftwnd_real_to_complex: rfftwnd.
* rfftwnd_threads_complex_to_real: Usage of Multithreaded FFTW.
* rfftwnd_threads_one_complex_to_real: Usage of Multithreaded FFTW.
* rfftwnd_threads_one_real_to_complex: Usage of Multithreaded FFTW.
* rfftwnd_threads_real_to_complex: Usage of Multithreaded FFTW.
linuxx86_64/lib/0000755003427200235140000000000010054447240012206 5ustar jimnamdlinuxx86_64/lib/libsrfftw.la0000755003427200235140000000117210015476202014527 0ustar jimnamd# libsrfftw.la  a libtool library file
# Generated by ltmain.sh  GNU libtool 1.3.3 (1.385.2.181 1999/07/02 15:49:11)
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname=''
# Names of this library.
library_names=''
# The name of the static archive.
old_library='libsrfftw.a'
# Libraries that this one depends upon.
dependency_libs=' lm'
# Version information for libsrfftw.
current=2
age=0
revision=5
# Is this an already installed library?
installed=yes
# Directory that this library needs to be installed in:
libdir='/Projects/namd2/fftw/linuxamd64/lib'
linuxx86_64/lib/libsfftw.a0000644003427200235140000141460210015476202014175 0ustar jimnamd!
/ 1077312643 0 0 0 4830 `
""ZZ'6'6..7n7n@j@jLFLFUUc>c>p2p2RRH:H:ONONWW__kZkZv6v6zzBBggmmtt{{""zz؆؆&&$$33RRBBVVrrVVޚޚ..
#*#*SnSnƶFFFZZZZZ..7r7r7r7r7r7r7r7r7r7r7r7r7r7r7r7r7r7r7r7ruuuuuuuufftw_no_twiddle_1_descfftw_no_twiddle_1fftw_no_twiddle_2_descfftw_no_twiddle_2fftw_no_twiddle_3_descfftw_no_twiddle_3fftw_no_twiddle_4_descfftw_no_twiddle_4fftw_no_twiddle_5fftw_no_twiddle_5_descfftw_no_twiddle_6fftw_no_twiddle_6_descfftw_no_twiddle_7fftw_no_twiddle_7_descfftw_no_twiddle_8fftw_no_twiddle_8_descfftw_no_twiddle_9fftw_no_twiddle_9_descfftw_no_twiddle_10fftw_no_twiddle_10_descfftw_no_twiddle_11fftw_no_twiddle_11_descfftw_no_twiddle_12fftw_no_twiddle_12_descfftw_no_twiddle_13fftw_no_twiddle_13_descfftw_no_twiddle_14fftw_no_twiddle_14_descfftw_no_twiddle_15fftw_no_twiddle_15_descfftw_no_twiddle_16fftw_no_twiddle_16_descfftw_no_twiddle_32fftw_no_twiddle_32_descfftw_no_twiddle_64fftw_no_twiddle_64_descfftw_twiddle_2_descfftw_twiddle_2fftw_twiddle_3_descfftw_twiddle_3fftw_twiddle_4fftw_twiddle_4_descfftw_twiddle_5fftw_twiddle_5_descfftw_twiddle_6fftw_twiddle_6_descfftw_twiddle_7fftw_twiddle_7_descfftw_twiddle_8fftw_twiddle_8_descfftw_twiddle_9fftw_twiddle_9_descfftw_twiddle_10fftw_twiddle_10_descfftw_twiddle_16fftw_twiddle_16_descfftw_twiddle_32fftw_twiddle_32_descfftw_twiddle_64fftw_twiddle_64_descfftwi_no_twiddle_1_descfftwi_no_twiddle_1fftwi_no_twiddle_2_descfftwi_no_twiddle_2fftwi_no_twiddle_3_descfftwi_no_twiddle_3fftwi_no_twiddle_4_descfftwi_no_twiddle_4fftwi_no_twiddle_5fftwi_no_twiddle_5_descfftwi_no_twiddle_6fftwi_no_twiddle_6_descfftwi_no_twiddle_7fftwi_no_twiddle_7_descfftwi_no_twiddle_8fftwi_no_twiddle_8_descfftwi_no_twiddle_9fftwi_no_twiddle_9_descfftwi_no_twiddle_10fftwi_no_twiddle_10_descfftwi_no_twiddle_11fftwi_no_twiddle_11_descfftwi_no_twiddle_12fftwi_no_twiddle_12_descfftwi_no_twiddle_13fftwi_no_twiddle_13_descfftwi_no_twiddle_14fftwi_no_twiddle_14_descfftwi_no_twiddle_15fftwi_no_twiddle_15_descfftwi_no_twiddle_16fftwi_no_twiddle_16_descfftwi_no_twiddle_32fftwi_no_twiddle_32_descfftwi_no_twiddle_64fftwi_no_twiddle_64_descfftwi_twiddle_2_descfftwi_twiddle_2fftwi_twiddle_3_descfftwi_twiddle_3fftwi_twiddle_4fftwi_twiddle_4_descfftwi_twiddle_5fftwi_twiddle_5_descfftwi_twiddle_6fftwi_twiddle_6_descfftwi_twiddle_7fftwi_twiddle_7_descfftwi_twiddle_8fftwi_twiddle_8_descfftwi_twiddle_9fftwi_twiddle_9_descfftwi_twiddle_10fftwi_twiddle_10_descfftwi_twiddle_16fftwi_twiddle_16_descfftwi_twiddle_32fftwi_twiddle_32_descfftwi_twiddle_64fftwi_twiddle_64_descfftw_gettimeofday_get_timefftw_gettimeofday_time_difffftw_configfftw_plan_hookfftw_create_plan_specificfftw_create_planfftw_destroy_planfftw_twiddle_sizefftw_create_twiddlefftw_destroy_twiddlefftw_versionfftw_strided_copyfftw_executor_simplefftwfftw_onefftw_twiddle_genericfftwi_twiddle_genericfftwnd_measure_runtimefftwndfftwnd_create_plan_auxfftwnd_create_plan_specificfftwnd_destroy_planfftwnd_fprint_planfftw_bufferedfftwnd_new_plan_arrayfftwnd_create_plans_genericfftwnd_work_sizefftwnd_create_plans_specificfftw2d_create_plan_specificfftw3d_create_plan_specificfftwnd_create_planfftw2d_create_planfftw3d_create_planfftwnd_print_planfftwnd_auxfftwnd_aux_howmanyfftwnd_onefftw_malloc_hookfftw_free_hookfftw_die_hookfftw_mallocfftw_freefftw_diefftw_check_memory_leaksfftw_print_max_memory_usagefftw_export_wisdomfftw_import_wisdomfftw_wisdom_lookupfftw_wisdom_addfftw_forget_wisdomfftw_export_wisdom_to_filefftw_import_wisdom_from_filefftw_export_wisdom_to_stringfftw_import_wisdom_from_stringfftw_node_cntfftw_plan_cntfftw_rader_topfftw_destroy_plan_internalfftw_complete_twiddlefftw_make_nodefftw_use_nodefftw_make_node_notwfftw_make_node_real2hcfftw_make_node_hc2realfftw_make_node_twiddlefftw_make_node_hc2hcfftw_make_node_genericfftw_make_node_rgenericfftw_make_planfftw_use_planfftw_make_empty_tablefftw_insertfftw_lookupfftw_destroy_tablefftw_estimate_nodefftw_pick_betterfftw_factorfftw_fprint_planfftw_print_planfftw_sizeof_fftw_realfftw_twiddle_raderfftwi_twiddle_raderfftw_make_node_raderfn_1.o/ 1077312482 14522 10060 100644 1472 `
ELF>P@@ WVfftw_no_twiddle_1xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@&`0 !x0
,12E0@
OXP @10fn_1.cfftw_no_twiddle_1_descfftw_no_twiddle_1 fn_2.o/ 1077312483 14522 10060 100644 1536 `
ELF>@@ LcBHcBD(X\$_(X\T^fftw_no_twiddle_2xGGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@G&0 !0
,12E0@
O7X 10Gfn_2.cfftw_no_twiddle_2_descfftw_no_twiddle_2 fn_3.o/ 1077312483 14522 10060 100644 1952 `
ELF>(@@Lc?F,MIFLB4HcE(HFdHDXE((DGEXAXDYA\A(E\AYA\.YAXDYD\((^AXA\AXD\L$2XRp0M\e8
G
05fn_3.cK500000000K866025403fftw_no_twiddle_3_descfftw_no_twiddle_3?N fn_4.o/ 1077312483 14522 10060 100644 1696 `
ELF>0@@ Lc'MB\DDXBB,$L>DNYfftw_no_twiddle_4xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@&@0 !X0
,p12pE0@
OX0 10fn_4.cfftw_no_twiddle_4_descfftw_no_twiddle_4 fn_5.o/ 1077312483 14522 10060 100644 2336 `
ELF>0@@Lc7F,MMIOIIF4F$A(By?qxs??fftw_no_twiddle_5xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @x`+ 0 &01P6P>2`Rx0M \eh
])
4F0fn_5.cK250000000K587785252K951056516K559016994fftw_no_twiddle_5fftw_no_twiddle_5_descl
fn_6.o/ 1077312483 14522 10060 100644 2240 `
ELF>H@@Lc'MKO[ID_F<MIBTFE(DD(B(F4FlD\DXBA\AXE(A(Dd$E(A\AXFDD\HcDXLH(HD(IHIA\AXE(EXX\$E\D(EXA\EXD5DXDT$A\D(AYAYDXAYA\FDAYAY\(X\(AXEY4,A(A\AXEYDYT$(BlX\T$E\AXE\4B$(AXA(D\\dAXDLVLB\׳]??fftw_no_twiddle_6xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @H0+@0 &x01p6p>2xR0M\e8
G
00fn_6.cK866025403K500000000fftw_no_twiddle_6fftw_no_twiddle_6_desc? fn_7.o/ 1077312483 14522 10060 100644 2976 `
ELF>8@@LcDwORB,LOMDt$HID(FF\D,F$EX?D\FFLc(OI%LDD$AXHFDd$E\FX\IF\$BLOD\$E(EXE\AXDd$DdLHE(EXE\E(EXE\AXDT$FTLHE((%D\AYDX(AYAYX5(XAY(AYX\(AY\(\XT$AY(B(AYAYDYXL$XAY\(AY\(AYDY\(X\L$BDYL$(DYl$YL$AYD(EYD$A\D(DYDXEY$A\Dl$DXl$E\YD\$X$DYYd$E\EXE(DXD\(AYEXF4Dt$D>DYt$DD$\DnDYD$D(EYYl$A\DL$DYL$EXD\$DYDXAYEXA(XA\D(AYEYX\$E\BTDXD$T$$YT$A(Y$\E\\\E\\AXE\(BDXDD\L>B\c>f??&>y?&H?fftw_no_twiddle_7xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
+ 0 &X01P6P>2hR0M\e
P
s)4?
J\0fn_7.cK222520933K900968867K623489801K433883739K974927912K781831482fftw_no_twiddle_7fftw_no_twiddle_7_descr9au fn_8.o/ 1077312483 14522 10060 100644 2368 `
ELF>@@LcDORLMHIMD<IF$FlFNB$E\E(M)FDAXBlFdEXD$E\OD\$DOBA(A(BAXA(FtE\L$D(T$BTD\XB$A\LcEXLMXE(HIORD\K(MI\D\DX(XA\AXD(AXD\T$DX\(X(\(\X(\l$X$A\>AX(X\(XBL\A(Bl%\DX\>J<~(A(L)BFAXE(EXD(E\DYAXA\E\DYE\YYAXA(D$\$\B24RH0M( \xe
<
%0fn_8.cK707106781fftw_no_twiddle_8fftw_no_twiddle_8_desc
fn_9.o/ 1077312484 14522 10060 100644 3392 `
ELF>`@@LcD?OID5LNFMHIB\FM)A(Dt$BTOAXD(A(M$IE\FLD\X(AYBDT$DXDl$D(DTEYD\EYBTIDD$D$Dl$E(DoEXE\D(E(EXEYF4EYAXD\B$E\DXYt$EYA(\Bt(((AXA\D(l$(D$AXDYT$A\FTA(D(E\F4XBDXLc\OILDd$DXHFd\A(\$AYMJ<A(IAYL)MAX(DYT$IKAXDY$\XE\D(AYE\EXD\A(E(XDXD\D$A\XYAY>DL$\T$Y(\X(BL,Dl> p?D>\?1>$?}D?׳]??fftw_no_twiddle_9xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @8+@0 &01p6p >2R0M(
\e
)4?JU
`r0fn_9.cK939692620K342020143K984807753K173648177K642787609K766044443K866025403K500000000fftw_no_twiddle_9fftw_no_twiddle_9_desc(> fn_10.o/ 1077312489 14522 10060 100644 3256 `
ELF>@@ATHcIHLRSIIHDIMdID(HFH)D\F$XD\HXE(IID,E\EXDT$$T$FB'F$E((E(XDXEX\\(AXA((EX(D\LAXE\FlA\A\d$A\Bd'DD$AXE\l$DX$Blt$D(D$D\DD$XB\D$E(LcD(KK(MMID\IXBLl$DXND\$DL$K[D(M)Y=LID\A(XD$IHE\AXE(EXEXD$E\XE(DL$EXA\E(EXD$\D(D\DX\$Dt$A\YA(D(\$YDXDY\$\$DL$D
E\A(AYAYAYXA(AYD(EXD\\l$Xl$E(A(D\DXL$\YL$DXD4F,E(BB&l$D\T$Yl$$X$Dt$DYT$\$\d$D\$EYD$l$AYY%\\$EY$AYY$l$t$E(DXAYDYD$T$DXAYA\DYL$D\DT$\DXT$A(D(A\E\\DX(BLEX\(XA(XXEX\A\DtDlF\DVBDB\L>Bd&[A\
>?y?qxs?fftw_no_twiddle_10x$ BSGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ +`0 &p016>2R@M\e
h
h` *
5 H0fn_10.cK250000000K559016994K587785252K951056516fftw_no_twiddle_10fftw_no_twiddle_10_descn
fn_11.o/ 1077312490 14522 10060 100644 4656 `
ELF>
@@LcATHcOLMSHIFMDoIFKBTMDl$FtE(ItNEXDE\$D$M)KIF'BL'HDL$,E(IIDXBFD\DHBTHDt$IE(IH)DXD\BtIID$D(EXD\dDd$D(EXD\BlD\$D(XD\BL$(AXD\HG>d\W?pg
?h?d}?xA?@?>fftw_no_twiddle_11x$S ENGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @S + 0 &01 6 (>2 R
@M\P
o
eX
P *5@KVa l$
wS 0fn_11.cK959492973K654860733K142314838K415415013K841253532K540640817K909631995K989821441K755749574K281732556fftw_no_twiddle_11fftw_no_twiddle_11_desc !F\s fn_12.o/ 1077312490 14522 10060 100644 3080 `
ELF>@@HcDIILRIIHBHB<A((FDFlXLM\IMIA(FX$YD$AXE(F$OD\DYE\BE(FlDL$D$DDLkXA((DYDXYEXE\DD$\tEXHDYDYIXHI)L$D\Dt$E\F4FXFTYDL$LcA(DYDd$AXD$E\\Dl$F,DY$A(XYD\$F\DT$OFDDd$E(F\>B$BB4 ׳]??fftw_no_twiddle_12x>GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @>0+0 &016>2R0M\e
8
@J
>20fn_12.cK866025403K500000000fftw_no_twiddle_12fftw_no_twiddle_12_desc1a fn_13.o/ 1077312490 14522 10060 100644 6840 `
ELF>
@@AWHcHLRLAVIIMIMAUIIIATIII)HUHHSXLLHHB$F/F/DD4DXFDXBDL$B4&\$5Y\$TYt$@E\D,EXD\$F4D$DXt$XA(AXDXA\DvDXA\E(<EXF$D\B,DXF<.DD$\$d$Y\$dYd$@Dl$=DYl$XY$PD$DYD$DDYT$TD$l$Yl$hD5DY$E\D$\\DD
DYL$dD\%A(L$DD$DYDXYL$xE\l$\Y$AYXd$\DY$EXD%DY$D(A\AXD\EXD=T$DY$A(A(\AXD5D\YDYt$x\t$D$$YD$hD
Y$EX\$D(EXDYD\\=EXE(X\D$A(AX(YE\YA\A(BLDXT$DD>\D$DD$D(D\Xl$EXA((DT$DX(X$E(\\$(D\EXEX\A\\Dl$E\E\DXXAXFFlDdFDBdF\.BT&\LBHĘ[]A\A]A^A_
׳?2># >ḙ>
>l<?@=s=>:>,>,>X>?,=<֙>׳]??fftw_no_twiddle_13x<;BUR M(N0H8SGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @;x+0 &p016P>2
R
XM\p
ex
` !,7BMXe p${(,048<@DHL
;0fn_13.cK1_732050807K256247671K156891391K300238635K011599105K174138601K575140729K2_000000000K083333333K075902986K251768516K258260390K132983124K265966249K387390585K503537032K113854479K300462606K866025403K500000000fftw_no_twiddle_13fftw_no_twiddle_13_descHsHDHDH@H+H;H^HD8<%4;DD,e$ 0(S\emufn4<`  ( D
o
5 fn_14.o/ 1077312491 14522 10060 100644 4416 `
ELF>
@@AWXHcAVAUATLcHO,dNMISO4MMMMIM)BF$6(Dd$DYd$AYD\D$AXAYDl$E\DT$\EYDYXDXT$A(DXX\E\B&D<E\D(EYE(D\DXFL$$DXd$X$T$l$FD\$YX$DY\$AYAYt$D$DY$DT$DYT$YD\l$AXD\T$YYT$Xl$E\BD$D\DY$t$A(E(AYE\DYt$AYEXDd$\Dl$AXEYDT$D\Dl$Y\X$DYXEYEX(A\XE\\A\DE(BlDXA\D\DT$T$BDt$DYt$Dl$EYYl$L$DYDd$DXl$AYDYD$DXAYT$D$YD$t$DYXt$Yd$YDXY\$D\XT$l$L$X\$YL$$Xt$AYY$D\DYL$D\$D$Xt$DY\$A\YD$\E(A\AXv\A\A\\((EX\\E\XFXFlBt>Bl6BL&d[A\A]A^A_5c>f??&>&H?y?fftw_no_twiddle_14x4A BJB B(_0GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @A h+ 0 &01 6 >2 R
PM(\P
o
eX
v *5@
KA ^0fn_14.cK222520933K900968867K623489801K433883739K781831482K974927912fftw_no_twiddle_14fftw_no_twiddle_14_descqz fn_15.o/ 1077312491 14522 10060 100644 5200 `
ELF>@@AUAXHcLcHATOLMMKDAhSLHH8DlBDDK\mFD(MA(IIDgAXB'D\E(A(DY\$IXEXE\Dl$DYl$4A(AXYDYd$(BdD\BAYDE(Bfd$(D\FDYL$Yd$\d$(EXE\D\A(XT$E(XE(\$\\$E\EXYXT$ D\AXE(D\d$YFBlDY%DLF\&DL$ DYT$ \$TD\X\$HDYDD$YE(EX(D\l$D\DYX\$$X$E(\$d$\d$E\E(Dd$$D\EXYAXYE\D\$D\\$D>E\D=hlDD$DYFTHDDYE(FLIDL$DY$D\\$\E\t$EXXt$HL\$,DXA(A(DYY=AXDYA\E\EXBTA\Ftll$DT\l$AY(DYl$YAXA\Dl$Xt$,\X$(Xd$\D$(4t$,\XBB$,H8[A\A]Ky?qxs?>??׳]?fftw_no_twiddle_15x,
BRX KXGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
+`
0 &01
6
>2
R
HM8\'e
v *5@
K
^0fn_15.cK587785252K951056516K250000000K559016994K500000000K866025403fftw_no_twiddle_15fftw_no_twiddle_15_descT}?`xGN { fn_16.o/ 1077312492 14522 10060 100644 3816 `
ELF>0 @@HcSHcIHLIHIBBD'LRGD<ME(IE(FD(E(BdIE\D\D\ILD\LH)H)E(A(I(A(D\AXE\DXXL$\$AYD\DX\$Xd$BlIXD$>\D,HtDYt$Dd$A\YDl$YXH)DYDYDXYD$AYLE\YD\E(Xt$E\EXD\$YDX(\(X\\X(AYB$DYDXL$BA\AXA\EXD,>BLDL[a^l?>5?fftw_no_twiddle_16xDGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @XH+ 0 &01P6P>2\Rp8M\eP
U
*=0fn_16.cK923879532K382683432K707106781fftw_no_twiddle_16fftw_no_twiddle_16_desc fn_32.o/ 1077312492 14522 10060 100644 7512 `
ELF>@@AUHcHcIATIIISHHHFD'DGtHRD(D(IID(IFDd$HB4.\X(\t$A(X\$d$dLA\EYBlA(EXYE(4AYDYD$dA(DYBT>D(EY$F.Y$HX$AYEYD$0EXDX$MIL,t$AXD(L(H\T$HiA\EYXA(D\(X(E(\D\E\A\D(BD$A\DT$(AXE(D$D\T$D\$EXXD$lDX$XXD$D\B4t$l\t$X,>DXA(DDLHDXA(DL>HAXDL$E\DXL$HDT$A\D\T$EX(D$D\$(BdMFlA\IE(IA(DL$E(AYDXL$A\EXD$D\$4DXt$4AYXt$EYEYE(E\EXDt$`A\DXt$\AXDl$tA(DXl$pA(B<>\(DXA\EXTD\D\DXBdAXID>D\ID$DDX$D$HDd$(LDXd$E(HHH)A(E(D\DXA(D$DX$AXE\A(A(E(EXE\\DXA(AXB<E\Dt$$\D\t$DA\Dl$TEXD\l$ DTL$BdDX\L$$\$D<XD\$D\\$DNDT$D
D\T$DLiHiD(DL$DYl$EXA\D$D\$E(A(EXA\DE(A(EYDY\$AY(DYT$EXE(DY(A(E\D\$TD\\$EXDTBt>H$\$D$Dt$Dd$D\t$D\$$FDd$xDT$P\d$8(D\T$@Hi٨IAXA\DYD$EYD\$(E(EXE\Dt$D\t$AYDYXE\D(AYDY(DXA(E\E(EXA\AXD\A(EX\E\EXA\X$DLX$DD>DT$DD$TDXD$FdB,DX$(d$Xd$D(D\$D$PDX$@L$xEXXL$8(DYA\A(D$AYDX$\AYXDY$E(,4>A(A(DYA\EXDT$DXT$EX(AYDYT$DXt$D\(YE(A(\A(EXA\DXA\A\\E\EX\XXF4EXD$$lBBBLDDH[A\A] 1T?9?G>{?^l?>5?fftw_no_twiddle_32x,6BKL NGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @6h+0 &016>2RHM@\(Ge0
*5@K
V6i0fn_32.cK831469612K555570233K195090322K980785280K923879532K382683432K707106781fftw_no_twiddle_32fftw_no_twiddle_32_desch{
fn_64.o/ 1077312493 14522 10060 100644 19304 `
ELF>;@@AWHcIIAVIIIAUIIIATLixUHi¸SLiʸHB,D7FJ,AX(D$F.D\$P\EXKID(M)IMD(IIDfILDXD(DY\$D(MixEXE\D(Ii8A(IiĸDXA\E\D(\DXB6Y$DA(EXDYD$D\A(A(EXD(A\D\FXD$<EXD\$,A\$FLYl$DX$Bt>D$pBd6DX$MF5D$ID\$D$l(DX$D$LYD\$M)(L)E(AYE\EXD\DX$lA(AY\$D\$@AYBDYF$>MD$IDX$MXM)A\DA(T$<$8AYA(YEYAYD%DXAYA(A(AY\EY\DXDl$4D$Y$D\$$p\$E(D$(D\$8Y$0DYEYYEYDDY$@E\D$D\$DXA(EXA\D
A(DL$(Y$@d$(DY$D$(Y$Y$0\DXDX(A\DXY$\(A\AXD\$@L$,DXA(XA(A\\DXB$d$4FD(D\X\$@\\$,AXD\d$4A(D(\DXA(D\BLXD\A(D(FlE\BTI\DXMi̸DXFAXML$XX$FDA(DD$8D$>D$HDX$B4HE\$lE(X$IHDD$ D$hD\T$ DX$ YD\$DE(F<DXD\MiXIiDd$D%E(AYE(DYDYDYDX$\$D$E(DY$l\$D\A(DYYEXD
A\DA(A(AYAYA(A(YY\EYA(DYDYXAYE\\$AXD=Y$,Y$D$DD$$<DY$<DX$X$,D$Y$,A\E(DD$DY$DXD\d$(Y$D\$DDXDY$<A\DX=Y$DXA(L$\d$X\l$(A\AXD(L$EXA(DX\A(\d$DXl$BFE((DX\XA(EXA\LdD\BlFlD\T$d$L$l$Mi̘D\$AXX\t$E(Mi`(E\\EX\D,XD$D(DX$HDIiĘD\IiXDT$A(L$DDLE\D,$BlD$B$D\$D$\$\D\$LX$L$X$A(E\E(\DXDXA(A(DYl$DYAXA(\AXYd$DL$A\EXD$D\DXDYFIHD$F\D\$HID$ID$X$DX$D$X$D$DX$$D\$T$L\$$LD$D\$D\$$D\$L\$AYl$LEYDYAYDYYt$LYE\YE(IiܠEYDXDY$LXA(IiD\DD$A(E(T$$YX$EYL$D$DX$AXD$LAXDYD\AY$\$XAYD\$LAYDd$EXXA(DX\BD\T$F$D(D\L$A(D\XXA((A\EXE(\XBTFd.T$D\,$BLXl$AhBtA\t$MiE\AXD(D\$(EXFO5AXB,6D<$D\D\$DX$$X$X$DdBT$EXX$D$A(DX$MiPA(A\EXDAYA\DYd$(EXDYF<D$L>FD6E\DX$IiܐDL$DL$(DYY=EXD\$(DYD\$(YY\DXDd$D$LD$Y$D\$D$D\$Dd$D$T$DX$D$D$TEYt$LAYDYDYD$AYDYT$DAYY$TD\EXAYDY$Dl$LDY$DX$\$DD$D$E\DX$D\DXA(DT$DT$LDY$A\EXD$D\$D\AYDYl$A(DX\t$YYd$XT$D\AX(AX(D\\XA(XB$.A\D\$A(\DXA((A(A\AXDd$EX\D\l$Bd\$A\EXDd$A\EXDl$E\BT.T$A\DD4EXLF<$D$AXE(X$D$TD\$DEXE(D\\$DYT$D((D\DXE\EXF\F,>D$DDX$XD$.=D$A\lLYAX\.E\Yt$HcDX$BdLLipMHBT>LH)H)I)HHILtmHi0IIDT$IDT$LiEYDYLiDXD\DD$$XD$DX$$X$L$DD$$D\$\$\$(EYD$@DYl$YD\$PY=$DY$DD$XD$HD\Y$HY%
AXDYYl$AYDYt$(\$\$AXD$E\DX$d$$YY$D$D=AYEYAYDY$\EX\D(DX(E\AXD$D\$A\L$DDX(DYY\$AYDYAXE(EXD\(XA(\t$E\\DXAXD\\$B<D,E(D\DXT$A(A(\DXA(EXA\\\Fl>Dl$DX\A(,$F$>BLEXDd$AXL$E\\L$DtHE\Dt$\$A(D$4D\$$D(LihE(IE\\DXAXDD$DXDXD$FL.D\<>DXF,6BT&A(F.F$&A\D(HiEXE\t>DXLiFt6LtLiDT$$hD$x\$DX$$hX$5D$t$d(X$A(X$AYD$tYD$dYD\$EYD\$D($x\$YD\DY$ \$0XLiDl$E(DY$DY=%Hi(DXD((EYD(AYDYE\DYD$(LiA\D(YEYD$DYDYEXD(YDY$\YY$8$EX\$D$8(X\DYE\D$DYA(EXD$DYY$(A\EXD\A(T$XA(E(D\XA\DXAXE\D(AX(E(\XE\B(\T$Xl$((\X(AXLA\L$BT>D$(\AXD\l$XD\B\\$DXA(ll$AXD4EXD$0A\F$>DX$ EXD$t\DX$E(Bd.F\&XT>A\D$dD\DX$DXB$l$t$D$>D$A\DX$F1>t?{?G>m~?6=E?g"?^l?>5?fftw_no_twiddle_64x<9BKM M(H0H8NGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @9PB+ :0 & K01P:6P:<>2:R:XMPK\:;e?p
pA *5@KVa l$w(,048
90fn_64.cK555570233K831469612K881921264K471396736K290284677K956940335K980785280K195090322K995184726K098017140K773010453K634393284K923879532K382683432K707106781fftw_no_twiddle_64fftw_no_twiddle_64_descp4y44444P4x4,,.0Z,y,,,,,z,,4,,3,,,,48
4Y
44414I444+4B44444,4($c ?~!a"""?#G#X##$;))J*r**+>+
,O.../0C/K/g//,70X0d2m23>3F3
46Y6 787$F7(777 ftw_2.o/ 1077312494 14522 10060 100644 1752 `
ELF>@@
DHHcH@@D9HcDDHIHIff>D4\nD(D~BLY(AYFEYDDvYDgHXA(A(A(AYYD\DYEY\A((EXXA\AXXAYA\AY(AYD\AYAX(D\A(W\AXDXD\BLDFdHǅB׳]??fftw_twiddle_3xFGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @F0+0 &H16>2R0M@\ ?e(P
xP
0AFftw_3.cK866025403K500000000twiddle_orderfftw_twiddle_3_descfftw_twiddle_3
( ftw_4.o/ 1077312494 14522 10060 100644 2016 `
ELF>@@
LcIcKIMHIHF<F\DFDVF4B6E(EYA(EY$AYLEYD(YD'EXEYDFoD\VE(EYD(DYYDXDYvHE\E((Y(YA\A(XA(D\(EXXE\AXE\E((A(DXD\A\D\AXDXDXBD\F<A\EXDD\_FTF$HׅXfftw_twiddle_4xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment@&0 !H,192M00HW``
@: &0ftw_4.ctwiddle_orderfftw_twiddle_4fftw_twiddle_4_desc
( ftw_5.o/ 1077312495 14522 10060 100644 2848 `
ELF>8@@HcMcHRIIIIHnD>DDtD(A(EYDnEYdDvAYAYB4BTE(DDYDgAXDYE(DYfA\DYD^BLEX(YE(YDYVDYE\vFH AXD\D((DYAYY(AYE(A\X\X%D(D(YY
E\AXD=E\AXD(D\$D(AXEYE\DX\(YX\Y=AXDXAYYDY(D(DDD\EYEXD\A(DY5AXA(DXE(\%Yd$E\D\BD,AXD\X%Yd$E\(EX\FXA\DTB\(AXD\BLDdJ<cn>?y?qxs?fftw_twiddle_5xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ + 0 &
H1P6P >2pR0M\e
8 f *5
CR0ftw_5.cK250000000K559016994K587785252K951056516twiddle_orderfftw_twiddle_5fftw_twiddle_5_desc9M`
_( ftw_6.o/ 1077312495 14522 10060 100644 2720 `
ELF>`@@HcMcLRHIINHIID~~FFdE(D(DEYDoEYDNEYBAYE(BLE\6DFAX,DE\D(A(D(YEXDYDVEXYD\DYA(F$A(Y,YD\DYDXDYfB\BL(YEXY(DNA\AXE(EXE\E(DYDY(YAXDLD\V H(AY(AYE(YX\A(D\DX(XA(X\A\Y5YDX(A\Y\F$AXE(((\XA(DXA\,A(
EXYAXD\EYD(XA(D\(AXDA\DtY5A\B\DY=D(YDX(\\FAXX\B,gBLBTJ<8?׳]?fftw_twiddle_6xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ +@0 &@
H1p6p$>2R0M
\eP
0 P
<0ftw_6.cK500000000K866025403twiddle_orderfftw_twiddle_6fftw_twiddle_6_desc2I ( ftw_7.o/ 1077312496 14522 10060 100644 4104 `
ELF>@@DSALcHcKIKMMIHHIHHffffDWABBLD&DT$Dv(DVE(DF,DYD,A(DYDYtYE(EYDDYB,EXBE(DL$DYDNEYD\v$E(DYDE\DYEXD^ E((YEXYE\E(EXE\DFA(DYlY~EXE(DYFDYD\$(YAXD\E(YVEXE\E(DXD\vH0E(YB$YBlX(Y\Y(Y(Y(XT$\
AXXX\AX\AYXYYAYXAYX\$X\AY\(X\BY
AYYY%AYDYXAYDYX\$\
AY\AYDY5\(\XBAYAYD=AYDYDX$\%AYA\AYE(E\DEXDYE\DXDXl$A\DE(DXEYD\\DoDD4D5F<(D=DYDYDYDX$D\%AYD\AXAXD\\AYBDX\$D(A\A\X\lDYB\DY
Y5AYY=AYAXX\$X\(A\X\BT\H<#[c>f??&>y?&H?fftw_twiddle_7xFGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @H`+`0 &H168>2R8M\/e
 *5@K
Yh0ftw_7.cK222520933K900968867K623489801K433883739K974927912K781831482twiddle_orderfftw_twiddle_7fftw_twiddle_7_desc/L]x%<O\j Cd
( ftw_8.o/ 1077312496 14522 10060 100644 2904 `
ELF>@@USHcIcLHRIIII)LIJIHIHfF4BDDfD^wD/E(DYA(EYYDLEYn0BEXFE(DvD\A\AXA(D^4EYEXYE\t$DVA(($AYDYE(DYBTAYDNYBLDXEYEXD~(\BA(A\EXD(E(DYd$A\DYfF(YDXY\AXA(DN,DYAYD\A(EY(YDDV EXE(\nA\AX(DYAYDX$D\A(F$EYH8YD(AXAYDL\(AYAYD(AYD(\XDX\A(D\XA(AXAXE\E((X\A(E\BDXl$\$D\D$(E(AX\Xd$A\(XXA\Dt$\BDDXDX\t$B\D\OBdl$A(A(F<F$\E(AXA\DXT$D((AXXY%\YY5E\DY((XAXE\EX\D\DXD$D\FlBLD,DTH<E[]5?fftw_twiddle_8x$ACGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
`+`0 &
H16,>2R@M@\/e 8
P
E
"10ftw_8.cK707106781twiddle_orderfftw_twiddle_8fftw_twiddle_8_desc( ftw_9.o/ 1077312497 14522 10060 100644 4752 `
ELF>x@@ATUSHcMcHRLHIIHNHH)IIHIIH~4DfDF(Dn,D(FB\DYA(E(DYLA(DYDY%AYD
YYWEYBA\D7D\DX=EXDD(A\E(DXB4E\EXYFlAYAYD^EYl$D\~d$A\DN D(YDt$E(EYEYT$DF$DYBTAXE(A(DYAYE\EYDV8DY(D\f\?1>$?}D??׳]?fftw_twiddle_9x$BCC GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @p+ 0 &0H1P6`@ >2R@Mx\e
*5@KVa
o~0ftw_9.cK939692620K342020143K984807753K173648177K642787609K766044443K500000000K866025403twiddle_orderfftw_twiddle_9fftw_twiddle_9_desc'9lzq?rz'9BJUm7JXc( ftw_10.o/ 1077312497 14522 10060 100644 4280 `
ELF>@@AUATAUSLcMcKKKILMMH,LHJHIHHIL)H? fftw_twiddle_10x,BDD A(GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @@+@0 &XH1p6D >2RHM\ ?e(
i
+6 $
DT0ftw_10.cK587785252K951056516K250000000K559016994twiddle_orderfftw_twiddle_10fftw_twiddle_10_desc,Igy$1v
K( ftw_16.o/ 1077312497 14522 10060 100644 5432 `
ELF>P
@@AWIDAVAUATUSH(ɉL$$FLcHMLHD$IHJLK4LL)HL$MKRL4HXH\$HMkhIL$LIHHHHLL)HH,HHD$HD$AA8Ei^l?5?
fftw_twiddle_16x<uBHB B(A0A8D`GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @u@+0 &H16\ >2\RpXM \eh
8^
+ <
9uI0ftw_16.cK382683432K923879532K707106781twiddle_orderfftw_twiddle_16fftw_twiddle_16_desc&F`s
*8Bv
( ftw_32.o/ 1077312498 14522 10060 100644 12360 `
ELF>0"@@AWIDIAVAUATUSHɉ$LcHIi۸LMHIHD$H$L$K<[MIIH\$hLILHL$L)IHHM)Hl$pHJJ,Ht$HK4L$IHL$`HHL)ILHILd$(ILt$@IHT$XIIIiӘLd$HMiL$8Hl$MiAXHHT$ HHHLt$MH$Ld$IIkhHMHT$MiHD$IiӰIiMiH$EBEjxAZ8A9AE\E(E(H$DYEqEYEYA$ELH$D(E\AYE(DYEA4DYETHD$pEXEj{?1T?9?>^l?5?
fftw_twiddle_32x< BKB B(A0A8GGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ (+` 0 &/H1 6 >2T@@AWHAVAUATUHSHxɉ$tQ5=LcIcHT$t$D$$D$ffLDHDTLDLHA(H$PD(MAYlEY\EYDhxKDeDuIA\E(D(IDYxEYIKBt%DYBL%H$8HH$XL$HEXH$0L$@DxL$`MiנIջXIA(DYA(Y(YEXYDD\XE(DYA(DYD(A(DXA(A\E(E\AXX\B\5E\E((Fl5N4DXD\M)\M`AXID$pD\
E(D$hD$lEXl
E($dDKD\A(xEYAXYID\IA(D(EX$`EYA\(E(D$\YD$TEYD(DY$XAYL$($DYFTA\BLEXXDE\FlD$A(L(HE(HEYBdDXYHD\D((L$ EYH$A\YAXE(DYEYD(MiǸA(EYD(YD\EXE(MiD\A(A(DX$AXE\D$A\EXE(DXD\Pt?a?Z>9?1T?E?g"?6=m~?{?G>5?^l?>
!"#$%&'()*+,./0123456789:;<=>?fftw_twiddle_64x<RBEB B(A0D8GGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @R[+`R0 &hkH1R6R< >2SRSXMk\HTgTePX
Z
+6ALWb m$x(,048@
R0ftw_64.cK290284677K956940335K881921264K471396736K555570233K831469612K773010453K634393284K098017140K995184726K980785280K195090322K707106781K923879532K382683432twiddle_orderfftw_twiddle_64fftw_twiddle_64_desc(4.0,y,,,,,P,y,[,,, ,A , ,c%,%,%,%,6.,>.,/,u/,0,!0,T0,0,D3$04(J4(Y4(4$4$4$5(5 5555 5 $6>6S6[6666 66689#9q99999:::::5;C;d;t;;;;;;<(<8>,G>,[?,c?,t?,}?$??(?(
@(@$+@A@v@~@,@@$@$@(AAXAC,C,D(OD,bD,sDDDE$4E$=E,JEE,EE$E(EF
F+F(4F(nF$G9HHHHI?I_IIIII
J J0JeJJJJKK"K4KBKdM(mM$M$M(MMM$M(N( N$NNN OfOsO{OO OOOP .P @P(@ fni_1.o/ 1077312501 14522 10060 100644 1472 `
ELF>P@@ WV"fftwi_no_twiddle_1xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@&`0 !x0
,12E0@
OXP @4 0!fni_1.cfftwi_no_twiddle_1_descfftwi_no_twiddle_1 fni_2.o/ 1077312501 14522 10060 100644 1536 `
ELF>@@ LcBHcBD(X\$_(X\T^8fftwi_no_twiddle_2xGGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@G&0 !0
,12E0@
O7X 4 0!Gfni_2.cfftwi_no_twiddle_2_descfftwi_no_twiddle_2 fni_3.o/ 1077312501 14522 10060 100644 1960 `
ELF>(@@Lc?B4MIFlF4HcD(HFTHEXE(%EX(D%AXDGDYA\E\AYA(.AYA\EYD\AX((VAXA\AXD\L2XRp0M\e8
J
07fni_3.cK500000000K866025403fftwi_no_twiddle_3_descfftwi_no_twiddle_3CT fni_4.o/ 1077312501 14522 10060 100644 1696 `
ELF>0@@ Lc'MOIHcIB4FH@D(FF4BLEXA\FlDOHD(HD(E(A((EXA\E\EXE\A((AXAXA\EXD\A\lAX<>\DDXDD$T>DNdfftwi_no_twiddle_4xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@&@0 !X0
,p12pE0@
OX0 4 0!fni_4.cfftwi_no_twiddle_4_descfftwi_no_twiddle_4 fni_5.o/ 1077312501 14522 10060 100644 2336 `
ELF>0@@LcDF,MMIOIIBF$HcA(HB4HXA(BDL@XE(FtD(DDX\BdD\BLD\H(H(YEXXAXA\D5D\DD(A(DXY\AYA(YAYYA(\XAXDYAYnE\D\(E(D\AXAXD\E(DXD\(X\A(DEYFAY<>A(EYAYE\XA((AXXE\\D\>LFz>qxs?y??fftwi_no_twiddle_5xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @x`+ 0 &01P6P>2`Rx0M \eh
` *
5H0fni_5.cK250000000K951056516K587785252K559016994fftwi_no_twiddle_5fftwi_no_twiddle_5_descj
fni_6.o/ 1077312501 14522 10060 100644 2248 `
ELF>H@@LcD_OI'MMB\E(IFOID\(F2xR0M\e8
J
20fni_6.cK866025403K500000000fftwi_no_twiddle_6fftwi_no_twiddle_6_desc"1 fni_7.o/ 1077312501 14522 10060 100644 2976 `
ELF>8@@LcDwORFFdOMDt$LIE(BHBI,D\A(DDDXB$BTD\$E(F\E(5(AXt$E\D(\DX$EXl$BlLcEXOILDXHA\LFT$EYDt$DY$DYt$DYD$YDXl$l$Yt$DT$DXT$AYD\$DY\$D$YDXT$DXT$D\DXT$AYA\DYD$DXD\l$A(DVDT$AYAXDYL$E\DYY$AXBdd$DlA\YA\Y\$Xd$X\$((A\A\\\X\X\BDdL>B\c>f??&>y?&H?fftwi_no_twiddle_7xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
+ 0 &X01P6P>2hR0M\e
P
v *5@
K^0fni_7.cK222520933K900968867K623489801K433883739K974927912K781831482fftwi_no_twiddle_7fftwi_no_twiddle_7_desc.Gf{ fni_8.o/ 1077312502 14522 10060 100644 2368 `
ELF>@@LcDWMORLIHFMID'F4E\B<FlONE(B$DT$M)DXDD\FFLA(A(BBlLcAXMJE\IDtAXL)\L\$DXHB\E((EXE\D(E\AXFLAXA(D\\T$DXBOIM(I\X((\XL$AXA\D(AXD\\$E\AX(XE(\(AXD\A((BdA(FDDD$XA\D(D\L$E\\X%DXD\LDYA(~\F<AXOFA\E(YE\YEX(EXD\DXT$Xl$A(FD\A(YDX\DX\XBLFTB24RH0M( \xe
?
'0fni_8.cK707106781fftwi_no_twiddle_8fftwi_no_twiddle_8_desc
fni_9.o/ 1077312502 14522 10060 100644 3688 `
ELF>@@LcD5OIDDLBTMIFFdHD(NFOEXA(M)D\E(B\?1>׳]??fftwi_no_twiddle_9x GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ X+`0 & 016 >2R0MP\e
*5@KV
a t0fni_9.cK642787609K766044443K939692620K342020143K984807753K173648177K866025403K500000000fftwi_no_twiddle_9fftwi_no_twiddle_9_desc`!Q*?Td fni_10.o/ 1077312502 14522 10060 100644 3264 `
ELF>@@ATHcLIHSILRD/IBHBlH)A(I_M\FID(HIIXd$B$D\4D$DX\$D(B'DT$E\FAXF(E(E(XDXEX\LD(XA((EX(D\tAXE\FdA\A\l$D\Bl'Dt$AXE\BdDXD$$D$D(DL$Dt$DtD\HcXLHBLDD$E(H@D(I(IIIA\IIAXFdD\IHXI)HE(HE\EXE(DXA(A(EXD\(XDXDL$\T$DX\d$YA\E(D(D$AXEXEXDYD$\D$B$L$%DL$D
DD$$A\D\T$D(A(DYDYD(AYD\AYXL$A\AYA\YL$D(YA\EYD(DXA(DX\$E\AXDD$AXDXD$D\B4D<t$D4Dt$T$>AYE(DYL$YD\YL$AX$FDDXD$\E(AYT$\D(D\YDXt$E\AXYF,D<>D(E(F&BD\$XDXEYE\(AXE(D\D\\Y$T$Y$t$DD$E\DT$EXDXT$DAYDYL$DYDtYd$F\\A\DV(\(XAXX\(\BDX\>BLBd&[A\
?>qxs?y?fftwi_no_twiddle_10x$BSGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @+`0 &x016>2R@M\e
h
hc
+
6J0fni_10.cK559016994K250000000K951056516K587785252fftwi_no_twiddle_10fftwi_no_twiddle_10_desc:U
[
fni_11.o/ 1077312502 14522 10060 100644 4656 `
ELF>
@@LcATHcOLMSHIFLMIDBlKE(MDIDXD,A(HB'HB$D\$DwD(H)B4NE\Dt$DLD(KIM)IDXD'AXG>d\W?pg
?h?d}?xA?@?>fftwi_no_twiddle_11x$W ENGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @W + 0 &01 6 (>2 R
@M\P
o
eX
P
+6ALWb m$
xW 0fni_11.cK959492973K654860733K142314838K415415013K841253532K540640817K909631995K989821441K755749574K281732556fftwi_no_twiddle_11fftwi_no_twiddle_11_desc (Acz fni_12.o/ 1077312502 14522 10060 100644 3048 `
ELF>h@@HcD_HILRHItDFlHB<HD(LE(M%MEX/DXA(ID<D\D(BtIAXBDYEXDYD\E(=DlD$E\HD(DY(DYA\D\$F$EXDT$D\F\LkXIHA(I)A(l$E(F,AXDYE\F<AXA(DYXDT$YFA(D$T$E\YA(FLAXE\D\$l$F\E(LcFO@X(YL$EXDYE\DD\BTA(AYDYO(AXD$AX\A(XYL$E\D$D\LF\lDYLL¸X(H(HNAXD\M)YXDY$\d$AXD\t$X\t$\$(XA(\(\X>\$>\\$$\X$DXA(BA\F4L$(D(\XD\X\$\\$D>A\~D$Ft\D$LBtMOt$I\t$(HEX\XA(A\EXD(XD\d$A\(X\L$A\(X\(X\(X\B,>(XBT(A\\A(AXT>A\DXD$D$EXXD$Dt$DXT$Dd$DXt$,BLDXd$BLDXL$A(IH((E(A\AXAXE\E\EX(D((A(E\AXA\AX\FDXB2R0M\e 8
M
40fni_12.cK866025403K500000000fftwi_no_twiddle_12fftwi_no_twiddle_12_descN fni_13.o/ 1077312503 14522 10060 100644 6464 `
ELF>
@@AWHcҸXLLRIAVIILMMAUIHIIATIII)HUHHSLHHB,wD'FF47$F?4/D$FE\D(BDt$8DXD\DD\\$D\A(DVYAXX\$8A\A(E(D\XA\DXDD$D$
Dt$YL$`DDYl$hT$YT$TDT$DYT$`D
DYL$Pd$Yd$dDDYD$T$Y$hYl$EXEYD\Dd$DYd$PXEXD$DY$l$(A\Dd$AXD\E\DDYl$d(AXA\DXDXYd$YE(E(E\T$EXE(DYEXE\DYL$E\A(EXD$XA\D\A(XA(A\E(BDAXDXlE\(BLL$D$XL$\$A\\\$A\Ft&DLA\DXT$DXBBl(A(F\DT$\\XAXBd\>TLHĈ[]A\A]A^A_
*׳?# >2>ḙ>
>l<?@=s=>:>,>?,=,>X>׳]?<֙>?fftwi_no_twiddle_13x<BUS U(N0H8NGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @8+@0 &01p6pP>2RXM(\0
O
e8
"8CNYf q$(,048<@DHL
0fni_13.cK1_732050807K156891391K256247671K300238635K011599105K174138601K575140729K2_000000000K083333333K075902986K251768516K258260390K132983124K503537032K113854479K265966249K387390585K866025403K300462606K500000000fftwi_no_twiddle_13fftwi_no_twiddle_13_descHD@ @h@ DD@8<90A4J,Ym$( 2gut(<4
s
fni_14.o/ 1077312503 14522 10060 100644 4424 `
ELF>
@@AWLcAXLMMAVHIMIHcAUHN,MIATMMM)SDDBKFO$I<hBMID,D(B4D(\HDXDWD(B<7DAXA(A(A(D\E\XD\B4E(E\d$EXB$?D$A\EXDt$DL$FD(MA(D$DT$FT\AhDXD\\A(MIH\D\$I)DXE(l$XAX(E(A(D\E\EXDXDL$D(A\DXDXA\\l$EXD\$D$DT$t$D\FtBl?IBL7XE(IB4'l$E\B\FEXD(XL$BT'E(IA(ILID\D\AXFXA\D$$l$EX(DT$(\A\DXBLDXI$Bd$AXD\$D\IF\IAXD(5D$E\DD$HF,6D(EYEXDXl$DYD\E\E\A(EXA\B&D,DT$D$YD$Dd$DYd$T$DYDt$DXT$DYt$DD$L$YDXD$XYl$DXD$E\YAXD$E\D(EYEXDXd$DYE(FDD(D\EYDY\$DXE\D$FDL$FDYL$DYDT$E\DYT$Dt$DYt$DX$E(D\T$YT$E\D\l$YD\E\EXDd$AXDL$DlDYDTDl$DT$DYDXL$XDYDY(EXE\AXD\E\E\DFE(EXE\D\DT$T$FLDt$DYt$Dl$DYYl$L$DYDd$DXl$YYt$DXYT$D$YD$DD$DYDXD$Yd$YDXY\$D\XT$l$L$X\$YL$DL$DXD$YDYL$D\Y$D\$D$DXD$DY\$A\YD$\E(A\XDFA\\A\\D((EXD\\E\XFXFlFD>Bl6BL&d[A\A]A^A_@c>f??&>&H?y?fftwi_no_twiddle_14x4` BTT Y(J0GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @` p+ 0 &01 6 >2 R
PM0\P
o
eX
y
+6A
L` `0fni_14.cK222520933K900968867K623489801K433883739K781831482K974927912fftwi_no_twiddle_14fftwi_no_twiddle_14_descc fni_15.o/ 1077312503 14522 10060 100644 5328 `
ELF>@@ATXHcLcSOMLOHXMFlIFt_BOdE(FD=EXD('LA(H(D$(MD(IB,D\d$DY
EXEYXE\E(DY5A\T$DT$HXDT$A(AYDd$XD(BTt$TA\D\D$DHkh$@B<E(D(E\DXEX\B,D\$PY=F\EYLDD$LDXL$FA(E\DlXJA\A(L)A(HYYHt$D4\LH\E(A(D(AXL$BLE\MD(DYIDYDXX\Y
E\EYFTXAhDL$Dt$DDt$DXt$ X\l$A\DD$D\D$ (DYEY(\X\XA\BtdLl\$\$Dl$D\L$DT$D\$DXt$L5\$L$X\$(D$DYE\D\$Y=EYDXD$AY%l$D4>\l$Dt$LHE(YX\$PAYDY$E(D\$\$(AXE\EXD\YAXD$HDD%DT$PDd$\$PB4DL$DYD\BAXDt$L$d$<XL$D$\d$8EXDY\D$<$\$DD$5D\T$E(DYXL$HEXYYd$YYIE(IHE\D(INEXDt$HD\L$HXD,>E\DD$0D$D\D$,E\Dd$EX(DEXDYF$DX$D\DL$EYAXD\L$DYD$\$\\$D\$D\l$@BT&YT$DYE(FAYD\DY
A\(E\XA(\FlEX(AXA\(DdDD$X$@t$Xd$\D$\BXDd>LBlHX[A\Vqxs?y?>??׳]?fftwi_no_twiddle_15x$
BLSpGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
+
0 &016>2(R@@M\e
y
+6A
L
`0fni_15.cK951056516K587785252K250000000K559016994K500000000K866025403fftwi_no_twiddle_15fftwi_no_twiddle_15_descTU&>y +\(h
fni_16.o/ 1077312503 14522 10060 100644 3816 `
ELF>0 @@HcSHcIIHLB<HBtILRD\D(MDgIDFtD\BLA(IIE(A(LD(H)A(H)IE\E(DdD\D\EXXDXA(l$\DXA(\BLA\DNDXE(((D\DX$AXD>H<D
F4IDt$DXt$I)I\MIXIHAYAYA(\XA(\BTDXD\\$$DXT$\$BlT$D4D$Dt$DXt$AXt$E\L$$E(l$AY$EYd$EYD\A\DX\$DX\$AXDDhB,A\IDTD5D\$DT$FYD\$AYAXH)AYDD$EYDYXAYD$AYLиXE\YD\E(Xt$D\DXT$YX(\(X\\XA(YdD$A(D\d$\AYDXB<EY$FD(AXE\D(AXE\DT$FDB\I\$DYDE(T$A\EYDYDXYl$AXDd$D\d$D\L(E(EYE(EYE\DYt$EXDT$A\EXEXD\(A(A(AXE\A\EXX\A\AXBtT($B^l?5?fftwi_no_twiddle_16xDGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @XH+ 0 &01P6P>2\Rp8M\eP
X
+?0fni_16.cK382683432K923879532K707106781fftwi_no_twiddle_16fftwi_no_twiddle_16_descb fni_32.o/ 1077312504 14522 10060 100644 7912 `
ELF>@@AVHcHcIIAUIILi¸ATSHHHF44D\HRWD(D(III(FD/IDXB/D\L,BtAXD(MIA(D(A(B'D(A(A\EXFDE\F\'L$XDXA\MID\I)EXL\D$HBt7$F<7D\D$A((I)E($BD$AXIA\IDAXME\I)DXD(E($D\D$TD\HXA(D(E(A($A\EXD\DXXD(EXA(D\XAXD$E\D$DXD5E\$D\D$AYA(AXEYE\$D\B,FFLEYBT(AYD(D$B,IAXD$E\B<FT$LiA(LiD$E(E\B\7EXB$7D(AXIDl$\FlDXI\D$LE(t$A(LF\HD\DXXHLi(\XB$MI(A\AXE(DXD\A(EXA\D$D($L$DXAXD$xD$L$A(DD$D\D$xE\\AXD(A(DD$tE(\DXEXE\D(D$pD$lEXDD$hXT$D\t$dL$t$D\l$A(DD$`FDX\((E(t$\B47\L$XBEXBL7E\Li°\AXEYE(EYLiD\D$Tl$PD$LDl$HAXD\AYEY$DDT$@FA(D\XB\ID(D(EXA\DA(DL$D$XD\thD(DXDX\A(E\DX\$Dd$<\E(D\X(D\$0(DDXA\E(A(EYA\YAXDl$,D$8DDL$,d$4A(AYA(YAYEYAYD\EY\A(DXDL$,DXT$$F<BBdDT$ FDd$((FdLiAXA\FLiʨE((DXD\$D(A(EXA\DLA(AXA\E\D(\DX(BAXD(XDT$\DEXL$E\A(D$A($A(AYAYA(EYEYD\AXB$7XFD\\E\AYFdXY(EYAYDT$$A\DD$AhXBDXL$FE(D$0$XD$E\X$XEXDD$\DX$(FIL>\IBTI)E(E(HiDXE(A(D\(A(A\Dd$DXd$xDXAXE\D(DXA(\DL$DXL$\A(DL$D\L$(B&X\d$DA\<DT$,$D\T$\$BLEXDX\$dt$\\$Bl&H\t$DfD%F(LiA\E(A(DYAXD$D\$(HLLiHA(E\AXD
Dd$$Y5D$DYD\D$LX$E\E(DYAYDXEYt$\E(\t$DYY5X(A\E(DXD\A\AXDL$A\DXL$AXDd$(>DXd$B,$A(BL&dL$X(XL$A\XT$LD$,DX$\XD\DX5d>LBHI$F&X$DYLiHHH(D((A\EXD(AXE\(D=E(A(EYDY
A\E(DY
YEXAYDL$\DXL$DAYDY
X(D\(\X\XA(AXE\Bd&A(DT$8D\T$L$\BlXl$pAYD$pA\t$EXAYDX$X$(AY(AXE(A\DL$4DXL$E\\X(L$EXFD(tEYdXd$AYT$PD$>t$AXAYE\DT$8DL$AYDXT$AYDYl$lD(EYDY\$PLiXXD\EYA(HiE\(A(D(Hi\DX(A\AXEXD\(D\A\AXE(E\FdB$DT$$BD\T$\DX4$FEX\t$ D$D\$Dd$XD\d$D5D,E($\T$@lA(BLFDDD$XAXEYD\D$HE\DY%D$YD\$Hi٘(HE(DXD\t$\t$A(DYAYEXE(DYEYA\DYE(A(D\A((EXAXE\A\AX\XA\EXD\\>DXB\BF,DXFdF\>D5D$FDX$$ $X<$X$DD$$DXD$\$D$XX\$DX$H$E(XL$@DT$t$%A(DYD(YAYDY=DXDYYL$\(E\E(AXDD$DXD$DXA\A(D$AYDYD$L$(DX(D\E(A(\\$DXA\E\EX\DX\DlXF\,DdTDXD$A\AXB{?1T?9?>^l?5?fftwi_no_twiddle_32x,~BNQ A(NGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @~+0 &016>2R HM\hep
+6AL
W~k0fni_32.cK195090322K980785280K831469612K555570233K382683432K923879532K707106781fftwi_no_twiddle_32fftwi_no_twiddle_32_desc(
0
e
E\j
fni_64.o/ 1077312504 14522 10060 100644 19720 `
ELF>=@@AWHcIIAVIIIAUIIIATLixUHi¸SLiʸHxF4DF/Bl/L,RDgA(LF,7HE\MD/AXD/IH,A(E(D$tFd7HHXL4D\E(A($x<EXLE\L$pAXE(H)B'E\IIE(IA(FL'D\DXBAXI)E\D$x(\$tXA(BD$pEXD(DXA(\B\IAXI(MI)AXD\XA\D(D$hD$xD\$lXA(E\XE\E(D(EXE\D$dD$`D$tD$pDA\DX$tDX$TA(D$PD(D\XD\$pXEXD\$\\A(D$XEYBEYD
FdXA\E(D$DFFDD\E($L$HB,EXB4ME\D$@I)F,FDD$`(F$D$d\BE(ME(ILi8EX$hE\tE(DX(D\DX<D\AYHXHD(EYA\$<D\$lAXXD$8$XAXBD<$lF\T$\$XAXD(LiʠA\E((DXAXD\E\A(XE(D\E\\X$`EXD$h$0A\$l$4E\(A\D$`\XEXE((XA(D\X$,A($\\D$ X$$A\D$hAXD\$\$(Y
EX($D$d$dA\DXY$DYEXDYA\A(A(D(D\DX\DXA\D$EXD$E\$AXD$$D$D$B\$B4B$FTFI(IF$F\X\BtLi`Li$T(A\FAXBDLiʘE(E\EXDDLHE(D\DX(A\AXDdLH,$PA(A\AXE\D$LlEXD$THiD(DX\$TE\D$HAXD$PD(E\EX(AXA\AXD($A($A(A\AXD$P$E\$H$E(X\$HDXA\DX\(A\D$DX$($A\D$D=DAXDYDE(AYA(EYD
DYYY%FDYE\E($AY$AXBLD$LD$D(IEX$D\$LXA(EYDYYD\YAYXA\FEYEY$XEY$$TD\EX(D($HiE\D$F$A\D$FTAXLiD$E(E\$@EXFDE\DXA(D$D\DX$XD$<B<D\$@BLAXM$$8E(l\LiXF(D$,DLX$4B$B\E\A(N:$(\A($(D$0E(X$D\BdDXMD\IID(H$DIXX$@IEXIHA\D$\E\($ D\A($D$$E(DXAXE\EXDA\AXD$8\EYA(EY$EY=$Y
YYAXAYA(A\AYD=A\DY$8(D(DX\XE\$DX$D$
DX$<D$(=Y$$$4D$D5DXD
AYDY$4A(EYAYD$,AXDX$0E\EYD$$AX$EYAXD$A\$ D$ DD5D\$,\$0(XA(\XD($B?D\AX$A(DD(DX$\AXE\\EYBDYDYAYDX$D$D$\D$$xD$BTF?$LiLiA(D\F?B?XLi$D$D($EXF4?A\Fd?DTHiLiPAXA(XD\F?<FL?($t(HHD(LipA\E\AXAXE(DXD\DD$(DA\AXE(HiEXE\A(E(XDXD\(X\$\D\A($tA\$pX$E(X$$D(\AXY5DX($h$\$XD$l\A\$dEX$`DXA\D$E\D$\$XE(D\DXD$TF4$DYD\$D$PY=FDAXB$D$DY%DD$D\$dE(D\DX$t\$\DXAXE(B$.D\F&Bl&$4\$D\O$A(Ft.D(D$$L\DDJEX(D(I(M)D(MA(IHLHE\D$$D\$AXE\D(MiMiEXA\E(EXD\A((IiA\A(Y$AXAXY$A\Y$Y$DX(DNXD(\D\X\DX4D\FLDXBlDD\LF4F$$D$t\$D\$DD$D\$D$DX$$X$D5$X$D$DX$DL$hA(\$hD$D\$YA\A(IihDXD$hAYI$Mi֨Mi(DD$DMiHA(AYA(AYYEYD$D\$d$x$D\$x\$XD\$\$L$t
D\$xE(DYEYDD((DYDXYA(AYE\DYD(YAXE(DYE\E(DY5Y$DYAXD$TD\$<D\L$dDY$=Y$D\$dY$DD$dY$A(A\D(DY$TA\EXD=DY$DX(DXA\DX5Y$T\(A\AXD$L$lD\A(\A(DX\DXB\(F>X\((A\AXE(D\AXE($X\$lA\L$xAX\L$tE(B<$xB$>(d$X$t\DXMiXA\lD\E\TEXD(A(IiA(Mi`D\X\DXA\D>BdEXBF$4>HDXt$D$tFDX$DD$DX$$X$D%$HA(X$$HA(X$D$D\$EXA(MiֈA\EXD$PD$D=DX$A(Bl$E(D\$XF\\$IDYE(AYAYEYDYA\DYD$=YA\DYD\$D5DX(\$TA(AYDT$Ld$HYD$D\$YA\$EXX$D$TDX$<A(L$DAY\A(EYAYX(AYAYA\E(DXXD\D\$@$D%DD$$@Dd$4D$4DY$EYAYDT$4DY$@AYY$E\Dd$4DY$PXE(DXE\EXD$PEYDL$DXd$PAXBD4HDt$LE(DXt$DD\(MipFL>AXMA\IAXK>LTHBdML)t$@Dt$PDT$HL$D\L$LA\$@E\DL$HD$DX$XE\$AX($E(X$EX(Dd$$D$\D$pXD\$`E\$\$A\BAXB4FD$pEXD$0X$`D$ D\$,MD\$BXA(\d$D(XD\DB$D\t$ T$DXT$d$$Xd$t$XA(\l$A(D(AXD\L$\\DXA(BD\\DX\$FtD\X$(DDAXX$DD$$D>D\D$DT$Bd>$X$X(A(MiưE\E(D$D\$E\\DY$A(MiְFtA\D$HEXDL$dXEXE\BDX$HDYF&B>M)FD&IIi0Dd$D$Y%$X$$(X$xDT$dD$(D\$x$\$D$DYD\$YD=Yl$dD$DY$AYDY$XD\DYD$4DT$DYDDX<$DYD<$D$dDXl$4DY$YAYAYD\$Y$\DXA(DD$D$`XE\DX$`Dd$D$hEYE\A(\DXt$D$$D\$$Y$$Y$hAYDY$X\DXT$4(AYA\EYDX$(\$D$A(YY$4X(AXD\t$A\E((D\L$DXD$X(\A(XA(\Bdd$A(B\.X\$\DX,$Xl$\B4>DXDd$DL$\t$B\4$A\F.EXDXBT>A((E(DtD\DX\E\DDXDL.AXB\$4DD$$T$X$D$,E\DX$B$AX$Y$D$X$DL$4E(DX$D$,D\$($,X$AYDYT$4E\DYAYEX\AYFtXAX$dFDLcD$LX.$$X$D\\$O$X$L\$LY$K(BT6A(A\EXDt$D\X\DXE\F.DXB4&B>A(F,6E(E(MiE\EXD\DXFl.FD&N$DT$Xl$X$Dd$DX\$Dt>M)T$\t$\T$D$D\$$D$X$D(DX$D\$Mi(Mi8EXD=D\X$X$\A(E(F<.E($EYA\X$YXDY5IiEXBdM>DYIiXDd.L)D$pD\$8DXME(EXE\DDYDl$DL$Y=D$D\$$\$E\$E(\$DYD$DY$<D$D\$DY$A\\$EXD5$=E((EYDYY(AYYAYDX$LA\D$Yt$A(EYY%YAXDY\$<D$PD\$@XE\YY$DL$A(E(DXD\DX(D\$A\D$L\AXDYY$D\(XAXA(\D\D(A(D\D\XA(A(D<\DXA(DX\\$FLE(\AXE\\DXD(4KRDXd$Xd$t$X$F,\l$D$pD\L$DXD$DX$8A(Mi(A\D(DXT$\X$X$E\AXLD$A\A(Fl>DX$EXBl6E\$B\.X$AXDFd\E(F<.D$A(BDX$DX$DXX$B<>AYD\D\$DF46E(IiE(E(IiEYDYDYEYAYEYDXDYE\A\Dl$EXl$Dt$$$\$D\$DDDY$E(D5$A(DY$HDY\$Y$\$A($PX$@AYA(D$DX$AYD\Y$YY$DY%XY$DY5Y$8XD$Y$A\DD$DY$8E\D(\$\$E\XAXE(EXD(AXl$E\DX$Y$H\(\XA(EXDXA\D\A((\DXA(D\L>XD\$A(FLA(DL$Dt$\DXt$DXA\AXA\B,EXl$D\$DT$BT>D\T$F,d$Dl$AXT$DdL$XEXE(IiژA\A\(E((E\EXE\EX\DXDl\D$.XD4$\.THx[]A\A]A^A_@G>{?E?g"?6=m~?1T?9?t?1>Z>a?>^l?5?fftwi_no_twiddle_64x<=<BKM M(H0H8NGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @=<D+<0 &L01<6<<>2<R=XML\X=w=e`Ap
C
+6ALWb m$x(,048
=<0fni_64.cK195090322K980785280K773010453K634393284K098017140K995184726K831469612K555570233K956940335K290284677K471396736K881921264K382683432K923879532K707106781fftwi_no_twiddle_64fftwi_no_twiddle_64_desc)4E444r4444u0~,00000I 0Z 0000D00000q
4z
4
4
4"44444444444404$, ( $!h!!!#$$${%%P,,,M1o11,2062223>445&5o555:6R88 P9$b9(k99:8: ftwi_2.o/ 1077312505 14522 10060 100644 1752 `
ELF>@@
DHHcHD.^DHDG((YA(AYAYY\X(\AXDXD\ODDDHǅ7fftwi_twiddle_2xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment@&0 !xH,192M(0HWXw`
8=
0ftwi_2.ctwiddle_orderfftwi_twiddle_2_descfftwi_twiddle_2( ftwi_3.o/ 1077312505 14522 10060 100644 2144 `
ELF>@@D<HcDDHIHIffDnlD6A(DYD~A(YDYB$nYFLHA(DYDE\AYD(DgAYDYXA(A(A\DX(XAXA\A\(AYXAYAYAXAYD\(7WD\AXD\A(L\FdDXBDHǅM׳]??fftwi_twiddle_3xIGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @I0+0 &H16>2R0MH\ ?e(P
xS
.0CIftwi_3.cK866025403K500000000twiddle_orderfftwi_twiddle_3_descfftwi_twiddle_3
( ftwi_4.o/ 1077312505 14522 10060 100644 2016 `
ELF>@@
LcIcKIMHIHFFDVDFF4Bt~E(EYA(EYAYD(EYdAYD'E\DYDoDX^E(DY(EYYA(YD\~EXHAXD(Y(DYE(D(\DXA(E\XE\A\EXA((A(DXD\XE\AXAXA\BDD\F<A\EX7d_FTBD$Hׅcfftwi_twiddle_4xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment@&0 !H,192M00HW``
@=
(0ftwi_4.ctwiddle_orderfftwi_twiddle_4fftwi_twiddle_4_desc
( ftwi_5.o/ 1077312505 14522 10060 100644 2856 `
ELF>8@@HcMcHRIIIIH7D,DTDvt$D<6A(lEYDf(AYAYDFAYA(DnEYFYA\BE(DYA(EYnD~YE\FTXEYE((D_EYDXDYB~AYD
H DXY(AYYE\D(\XE\AXD((D(AYAXAXE\Dd$A\(XDY\Y
YAXD(DXYA\D
DXE\D'EY\Dd$A(D\DXAXDd$D\X\$E(D(D\DXAXE\F4D$DBDYgY5%AYDYAYE\AY(XAXA\D\((XAX\D\DB\BLD\J<Wy?>qxs?y?fftwi_twiddle_5xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ + 0 &
H1P6P >2pR0M\e
8 i
+6
DT0ftwi_5.cK559016994K250000000K951056516K587785252twiddle_orderfftwi_twiddle_5fftwi_twiddle_5_desc64<IQYg( ftwi_6.o/ 1077312505 14522 10060 100644 2728 `
ELF>`@@HcMcLRHIINHIIFBDFD~DgDBE(DYA(EYB\YfEYD4E(l>E\DnDX(Y(A(E(YEYEXYE\YDFE\AYEXnA\E(DYB\DYXB4D\fDX(YE(YD\E(DX(YYD\DXF \dX(V$H(YޅY(YY(\A(XA(\X(X(AX\A\Y%YDX\YAXE(FD(\(EXA\(\XYAX4D%A(D\EY\A(Y5AXE(AXD\A(EXDA\DlB\DY=D(Y\DXAX\(FB$oX\BLBTJ<C?׳]?fftwi_twiddle_6xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ +@0 &H
H1p6p$>2R0M
\eP
0 S
.>0ftwi_6.cK500000000K866025403twiddle_orderfftwi_twiddle_6fftwi_twiddle_6_desc.Q ( ftwi_7.o/ 1077312505 14522 10060 100644 4104 `
ELF>@@DSALcHcKIKMMIHHIHHffffDWAD4DD~(D~,DT$D/DD^B,BtD(E(Dl$EYB$AYE(A(DYBLDYYA\DYvEYlEYE\D(DF D^$DX(YEXYE\E(E(A(DYDXY~EXDYE\DYnFD(YLDYDXE\$\VvH0DXE(YE(YEXE\E(D\AXD(YDY(Bd\B4DXY(YYYA(\T$X
AX(XAXD\\XXAYYYAYXAYX\$X\AY\(X\BY
AYYY%AYDY%XAYDYX\$\
AY\AYDY5\(\XBAYAYD=AYDY5DX$\%AYA\YE(E\DDXEYE\DXDXd$A\DE(DXEYD\\DgD%D4D5F<(D=DYEYDYDX$D\%AYD\AXAXD\\YBDX\$D(A\A\X\tY=B\DY
YAYDYAYAXX\$AX\(\X\BT\H<#[c>f??&>y?&H?fftwi_twiddle_7xFGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @H`+`0 &H168>2R8M\/e
+6AL
Zj0ftwi_7.cK222520933K900968867K623489801K433883739K974927912K781831482twiddle_orderfftwi_twiddle_7fftwi_twiddle_7_desc!1N_z'>Q^l~!De
( ftwi_8.o/ 1077312505 14522 10060 100644 2904 `
ELF>@@USHcIcLHRIIII)LIJIHIHfF<FLDVDfDwn4A(EYA(EY\D(AYAYD/DYBE\BtDNYXE(E(A(DYEXYE\DXD\DD$DF0E(DYB\DYBD\EXD^A(A(DYYE(BE\FLX~A\(YDXYEXd$D\fD$D~,D(YA(DYDYL\AY~(DX((AYDNYV$A(A\YXE(4\XDY>DXD\F l$H8(Y(YtA\DYX(AYAYD(Y(X\X\A(XD\D$AXE\X(A(\XBD$\t$T$E\DXT$\Xd$(X\A(AXBDE\BT(AXD\$(X\A\EXE(_BdAXD\l$(BF$AXD(A\A(D\AXDY(Y%A\YAXYE\(AX(D$XAXB<\\DXDD\tBLD,DtH<R[]5?fftwi_twiddle_8x$ACGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
`+`0 &
H16,>2R@M@\/e 8
P
H
#30ftwi_8.cK707106781twiddle_orderfftwi_twiddle_8fftwi_twiddle_8_descoz( ftwi_9.o/ 1077312506 14522 10060 100644 4720 `
ELF>X@@ATUSHcMcHRLHIIHNHH)IIHIIHBF\DF(^,DdDVnA((5YE(EYDwD(EYYEYD'D\AYDYD^D\YlB\E(A(E\YEXDF$X$EXD
AYA(AYF,DYYEYD$D\Dt$E(DXD\BDY5EYE\DNDd$E(DYn\?1>?׳]?fftwi_twiddle_9x$BCC GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @P+0 &H106@@ >2R@MX\e
+6ALWb
p0ftwi_9.cK642787609K766044443K939692620K342020143K984807753K173648177K500000000K866025403twiddle_orderfftwi_twiddle_9fftwi_twiddle_9_desc#u0cpG]nvIW_n1L\+9D( ftwi_10.o/ 1077312506 14522 10060 100644 4248 `
ELF>@@AUATAUSLcMcKKKILMMH,LHJHIHHIL)H/ADd/DF D^$DO\E(EYA(DYDvAYBtDYD/E(DYDfE\DYDXA(B? fftwi_twiddle_10x,BDD A(GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
@+ 0 &8H1P6`D >2RHM\e
l!,7 $
EV0ftwi_10.cK951056516K587785252K250000000K559016994twiddle_orderfftwi_twiddle_10fftwi_twiddle_10_desc#o}3D7k( ftwi_16.o/ 1077312506 14522 10060 100644 5440 `
ELF>P
@@AWIDAVAUATUSH(ɉL$$>LcHMLHD$IHJLK4LL)HL$MKRL4HXH\$HMkhIL$LIHHHHLL)HH,HHD$HD$EY8Ay^l?5?
fftwi_twiddle_16x<mBHB B(A0A8D`GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @m@+0 &H16\ >2\RpXM(\eh
8a!, <
:mK0ftwi_16.cK382683432K923879532K707106781twiddle_orderfftwi_twiddle_16fftwi_twiddle_16_descQ%3&Imy
( ftwi_32.o/ 1077312507 14522 10060 100644 12296 `
ELF>!@@AWIDIAVAUATUSHxɉ$tLcHIi۸LMHIHD$H$pLl$xK<[MIIH\$XLILHLD$hL)IHHM)Hl$`HJJ,Ht$@K4L$IHL$PHHL)ILHILd$(ILt$8IHT$HIIIiӘLd$HMiL$0Hl$MiAXHHT$ HHHLt$MHT$L$$IIkhHMHT$MiHD$IiӰIiMiffHD$xEJxEzAb^l?>5?
fftwi_twiddle_32x<BKB B(A0A8GGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @'+ 0 &/H1P 6` >2 R!XM/\h!!ep%
8'!,7BMX 
fw0ftwi_32.cK555570233K831469612K980785280K195090322K923879532K382683432K707106781twiddle_orderfftwi_twiddle_32fftwi_twiddle_32_desc
x
Msr{2>Q]ouqy9QwUcBr)JpP( ftwi_64.o/ 1077312509 14522 10060 100644 27912 `
ELF>V@@AWHAVAUATUHSHɉ$SLc
Ic؋H\$L$D$T$D$ffLDHDL=L\=HD(O,E(NEYDD5DYDT5EYD`L$DuImEXA(D(OEYBdDYBAYMH$H$IL$L$pE\(DxxYYL$L$OME(IEYE(EYEXE\DxE\DXE(A(MiDYA(DYA(Mi߸DXpD\(A\AXE\AXE\D(Ii8XA((D\A($A(F\%XXD$A\FL%A\XEX$EY\`$$$D$D($D(L$EYщ$DIDEYBDAYBlL$A(IE(ŉ$YBL
DYEXL$DYD\L$DYB\
DL$AXA(ME\A(E(IDYF\5XFL5D\YA((DA\AYEXAYE(DY(DY$MiE\DMixDXE(EYD$EYE(A(D\DX$AXE\E(E\\EXD(X((A($$EXA\A\EXEYE\DY$YEXY$Y$A\AYAXD$DY$AXA\$X$$$A($D$H$D$H$P8L)$pp{?Z>a?t?1>1T?9?5?>^l?
!"#$%&'()*+,./0123456789:;<=>?fftwi_twiddle_64x<WSBEB B(A0D8GGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @WS]+S0 &lH1S6S< >2UR0UXMl\UUeY
\!,7BMXc n$y(,048@
WS0ftwi_64.cK098017140K995184726K773010453K634393284K195090322K980785280K471396736K881921264K956940335K290284677K831469612K555570233K707106781K382683432K923879532twiddle_orderfftwi_twiddle_64fftwi_twiddle_64_desc+440,J,e,,[
,,,,,,; , ,!,%,%,%,&,.,.,/,/,/,/,0,0,4(4$4(5$T5(e5$5(5$666 66 77 %737F7S7a777 8?8.:6:>:c::::;I;Q;;;;A<O<X<m<<<<<<=4=l>,?,?,@(%@,:@$}@@@$@(@@5A$BA,TA,]AA(A(AA$
B"B"D,ED,wD,D,EE(*EiEEEE,!F$*F$3F,IF(`F$FFFF(F($G$JHH&I6IIIIJJJJJJJ
K0K=KOK\KjKKKLLrM$"N(uN$}N$N(N(N$)O(OO PPP3P ^PPPP PQQ#Q;QQQ (@ timer.o/ 1077312509 14522 10060 100644 1480 `
ELF>@@H(1H$HD$HT$H(ÐH$HT$Ht$H)HL$HH)H$HHT$xHT$HD$H@BHOHHHxHD$HL$HT$HD$xD0<bGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.data.bss.rela.eh_frame.comment @ &,6P10 @7I@
0M $1 btimer.cfftw_gettimeofday_get_timegettimeofdayfftw_gettimeofday_time_diff @ config.o/ 1077312509 14522 10060 100644 5664 `
ELF>@@ GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.comment@&@ !,(1(G:H j
E\t0G_v7Ph,E]v.CWl)?Tconfig.cfftw_configfftw_no_twiddle_1_descfftwi_no_twiddle_1_descfftw_no_twiddle_2_descfftwi_no_twiddle_2_descfftw_no_twiddle_3_descfftwi_no_twiddle_3_descfftw_no_twiddle_4_descfftwi_no_twiddle_4_descfftw_no_twiddle_5_descfftwi_no_twiddle_5_descfftw_no_twiddle_6_descfftwi_no_twiddle_6_descfftw_no_twiddle_7_descfftwi_no_twiddle_7_descfftw_no_twiddle_8_descfftwi_no_twiddle_8_descfftw_no_twiddle_9_descfftwi_no_twiddle_9_descfftw_no_twiddle_10_descfftwi_no_twiddle_10_descfftw_no_twiddle_11_descfftwi_no_twiddle_11_descfftw_no_twiddle_12_descfftwi_no_twiddle_12_descfftw_no_twiddle_13_descfftwi_no_twiddle_13_descfftw_no_twiddle_14_descfftwi_no_twiddle_14_descfftw_no_twiddle_15_descfftwi_no_twiddle_15_descfftw_no_twiddle_16_descfftwi_no_twiddle_16_descfftw_no_twiddle_32_descfftwi_no_twiddle_32_descfftw_no_twiddle_64_descfftwi_no_twiddle_64_descfftw_twiddle_2_descfftwi_twiddle_2_descfftw_twiddle_3_descfftwi_twiddle_3_descfftw_twiddle_4_descfftwi_twiddle_4_descfftw_twiddle_5_descfftwi_twiddle_5_descfftw_twiddle_6_descfftwi_twiddle_6_descfftw_twiddle_7_descfftwi_twiddle_7_descfftw_twiddle_8_descfftwi_twiddle_8_descfftw_twiddle_9_descfftwi_twiddle_9_descfftw_twiddle_10_descfftwi_twiddle_10_descfftw_twiddle_16_descfftwi_twiddle_16_descfftw_twiddle_32_descfftwi_twiddle_32_descfftw_twiddle_64_descfftwi_twiddle_64_desc
(0
8@HPX`hpx !"#$%&'()* +(,08.@/H0P1X2`3h4p5x6789:;<=>?@ABplanner.o/ 1077312509 14522 10060 100644 9976 `
ELF>p@@
Hl$Ld$L$H\$Ll$Lt$HhAHL$(ELL$ 1Ʌ~cAAÃ!بuGH$0Lt$0DLHHtDHLH{ HH\$8Hl$@HLd$HLl$PLt$XL$`HhËL$pHT$ ALL$(LD<$L$HT$DDHHtPHLDC0DL$p1DDD$E{$s4$DH$0HHNDL$pH\$ ADDLD<$DL$H\$LL$(aHHqffH\$Ld$Lt$Hl$Ll$AH8AtgLcLHH1Ht0NLDAHD$HILH\$Hl$Ld$ Ll$(Lt$0H8E1A1$H\$Hl$Ld$ Ll$(Lt$0H8fffffffffffffffH\$Hl$Ld$Ll$Lt$L$HxAEHL$@D$D$AH\$DH$0HL$LL$(DHL$HLk0DL$p1DD$`Dl${$Ds4$DbLL$hDD$`DDT$pDDLLL$D$LL$ ADT$HHubug in planner
ư>{Gz? _B@x$bp$DYG@l$eb<BEB B(D0F8D<PBBE E(D0C8G,,?OTG`GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.data.bss.rodata.str1.1.rodata.cst8.rela.eh_frame.comment @ &`,`12`@p RXMP&\eh rpe)?1PFKPV [j
`2M`l6QVplanner.cplanner_wisdomplanner_normalplannerfftw_measure_runtime.LC8.LC3.LC10.LC5fftw_plan_hookfftw_create_plan_specificfftw_make_empty_tablefftw_lookupfftw_use_planfftw_destroy_tablefftw_complete_twiddlefftw_insertfftw_wisdom_addfftw_create_planfftw_mallocfftw_freefftw_destroy_planfftw_destroy_plan_internalfftw_wisdom_lookupfftw_configfftw_make_node_notwfftw_make_planfftw_make_node_twiddlefftw_pick_betterfftw_estimate_nodefftw_twiddle_genericfftwi_twiddle_genericfftw_factorfftw_make_node_raderfftw_make_node_genericfftw_diefftw_gettimeofday_get_timefftwfftw_gettimeofday_time_diffas0:4
I!m"x
r#"
[!"$
#"8LUb$
B#k"v~$%0 %V &_
' (
%
)
"
(5$Id%*"'4$S%w
+,!
,m
v
,
.
.
1.e.r
*:a Hp`p0twiddle.o/ 1077312509 14522 10060 100644 3800 `
ELF>H@@ATAUHSHHunH[HteD;#uHKH9tLH@H uQ9Uuy9}uƋ} ;y u19}LE(HI(HcDE9u9C H[]A\ÿ(D%HDD HhHHC HCHSHH[]A\fffffffffffSW ʅ҉W u&HtHH9tHHu[[HKH{H
+H[fffAW*IAVAUATUSHxHf
^\$`rv2D$<AD$DAG ʉD$@t1D$<L$@HcHDt$R^\stwiddle.ctwlistfftw_compute_twiddle.LC6fftw_twiddle_sizefftw_create_twiddlefftw_mallocfftw_destroy_twiddlefftw_diefftw_freecossin
"
*
/^
5Ok"<8 Hh@executor.o/ 1077312510 14522 10060 100644 6784 `
ELF>@@
AWAVAUE1ATUHSHˉ$A9}1McLcAJDA9JD;l$A}AMDD$D<AΉ$L$IcALTtDDDLDTD\IcƉLEIcHcT$E4Dd$Hct$Dd$D;l$DDLDD\[]A\A]A^A_ÐHl$Ll$Lt$L$H\$Ld$HXAIHHDEtVrCfffH\$(Hl$0Ld$8Ll$@Lt$HL$PHXDDLUϋYDHI t$D$HDL$AŉAEDl$sHUEDLHrDUwYDHI t$D$HDL$AADD$HMEEDLHqU DaDHI(t$D$HAELD$$AADD$H} LMEDDHwLUfffLl$Lt$H\$Hl$Ld$L$HXIAGMDl$`T$h/tTW0HO ADD$`H\$(Hl$0Ld$8EЉT$hLl$@L$PLLLt$HHXf fffftMHO _0ET$DD$4$ELLމ\$H\$(Hl$0Ld$8Ll$@Lt$HL$PHXL Arx7H\$(Hl$0Ld$8Ll$@Lt$HL$PHXDO0HO LH\$(Ld$8Hl$0Ll$@ELt$HL$PLHXDDLLAW;AAșIO LED$DT$Dǉ<$LŉAAl$IWEDLHrAWA_AșIO ELD$DT$DL$AADD$IOEADLHqAWEgAșIO(ELD$DT$AELD$$AŉD$ MG MODLIpEAWLt$H\$Hl$Ld$Ll$IHHIG/uULo AErqff@H\$ Hl$(Ld$0Ll$8Lt$@HHfDO0HO AH\$ Ld$0Hl$(Ll$8Lt$@HHLLAUH\$ Hl$(Ld$0Ll$8Lt$@HHEEIM AD$D$ALD$ǉŉD$IUALHrAU&A]IM AD$D$AL$AĉD$IMAADLHqAUEeIM(AD$D$AELD$$ǉŉD$/I] MMADLHsAUlfffffffffAWEAVEAUATUHSHHHT$0$DHt$8ue1Li;$}FE11ېH$0HT$8HcIcH4DHsDDLUD$$$$D$$(T$,D9l$$fffD$DDMEHM HD$D$D$AELEAĉǉEDd$ZHMEDLHqUrD$D]EHM EHD$D$$DLAADD$LEEDLIpDD$DUD$D]EHM(EHD$D$$DLAADD$LU LMEDLIrUffffffffffAWIAAVEAUIATIUSH8HHՃ D1ۃ91LcHcJDD9IDD9}zHcËTLtDDDLDTD\AHATALCAHAtACAHEDELCAHETE\D9Mu#H8H[]A\A]A^A_DDLARH8[]A\A]A^A_ùDHLARAzDEIJ LAD$Dt$Dǉ<$HLT$(ǉÉD$LL$(AHIQHrAQHcHL$(HLT$(HAPAZDELADHD$4IJ D$D$Dt$$LT$(HL\$(T$4AEHIKHqASAZDELADHD$0IJ(LT$(D$D$Dt$$L\$(T$0AHMS MKIrASfAWIAVAAUEATUSHHHT$8Ht$@DL$4$T$0u@1LaD9}&1HL$@HcDHx@@AWAVAUAATAUHSDH(H$ DL$HcHD$HD9l$;D$EWD$D$AHHD$EIHcT$DD$EE(L4T$ALcfffffHL$ 1A(A(LD9}bNDDHcQ\lA(A(YY)9DYLLY\DXXAXuA:ArEIAlHct$LD$ 1D9I}Ht$HLcNL
HD9D$L$L$L$D9l$H([]A\A]A^A_fffffffffAWAVAUAATAUHSDH(H$ DL$HcHD$HD9l$;D$EWD$D$AHHD$EIHcT$DD$EE(L4T$ALcfffffHL$ 1A(A(LD9}bNDHcDQl\(AA(YY)9DYLLYXD\XAXuA:ArEIAlHct$LD$ 1D9I}Ht$HLcNL
HD9D$L$L$L$D9l$H([]A\A]A^A_x<BBB E(D0D8G`<\BBB E(D0D8G`GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.data.bss.rela.eh_frame.comment @4` &t,t6x10 @/I8
@L ,6generic.cfftw_twiddle_genericfftw_mallocfftw_freefftwi_twiddle_generic, 0 `fftwnd.o/ 1077312510 14522 10060 100644 15944 `
ELF>'@@AWfWEAVIAUAATIUHSHOf1D$@9}HwHcڋ$@<9ʉ$@D$Df
D$@L$H~T$@1ɐHcDʉttuD$<HD$`HT$hHD$pHT$xHT$hH$HD$`T$DH$k\$DE1MDHLD$D<$uH$HHT$hH$HHD$`H$H$H*HT$hH$H$H$H$HD$`d$H*YfT$HT$XHL$xH$HD$PHT$pH$X]T$HT$HH*HT$XHL$xH$HT$pH$D$0HD$PH*YXD$0f.?fDL$HfD.
Gd$DHD$`HT$hH$HHT$hH$HHD$`H$H$L*HT$hH$H$H$H$HD$`DD$H*Y=ft$HT$XHL$xH$HD$PHT$pH$X]t$Ht$HH*HT$XHL$xH$HT$pH$HD$Pl$(H*YXD$(f.D$<$<HT$hHD$`6fDT$HD*\$DE^AHĨ[]A\A]A^A_ffffffAVIAUAATAUS1Ʌ19}Hc1A<D9@1HH@EH@H@ H@(H@8D`Dh@4@0McJHHHEHHEH}1HE D9BD}QLE0E\H] DD\)LcDGFFTD9}HcօAAuD9fH[]A\A]A^HÐAWAAVAUAATIUSHxT$tLD$hDL$dHD$X1H$XDH$h Ȩu"H\$XH$!ȨIcE1HHD$PHHHt"1D9}ffffHcD9HI1EMA}1$L;l$LAtXDxTHcLcA4C;4tGxLcC;4t9fffyAHLE9I<H~A9}.McIc։J4HD)fffffMILHuDd$,D9Bl$<\$)9l$
\$fffLcHcKtI;ttfffxvLcK;tuxhD9LH$1H([]A\A]A^A_fffH$t
H$LH([]A\A]A^A_HcHHD$LcKHtfHIL#T$I LT$t$t$(t$Ht$ H4$Ht$HfffffffH(AD$T$Mȋ$@HT$8t$DL$0Ht$$H$DH(fffffffHAE1D$H$HffffffHIL#D$AD$H$I LD$E1t$Ht$HfH(AAt$$T$Ht$DE1DD$H$H(fffffffAUATIUSHHH_(DoHtW1D9}HffffHcHcH4H;4tffffHcH;4uD9fHI$Hu0I$Hu5I$ Hu:I$8Hu?HL[]A\A]I$HtI$ HtI$8HtHL[]A\A]HcH{Gz? _B@plan for rank 0 (null) transform.
 using buffered transforms (%d buffers)
plan is same as dimension %d plan.
 using unbuffered transform
plan for x%s%d transform:
* dimension %d (size %d) x<BIE E(D0D8G4\?BEE D(A0<>BEB E(D0A8D,[BEA D(D0<kBBE B(A0A8DD6A<dBBGE E(D0A8D@J<BGE E(D0A8D`FD FD0<'D \ND FD0,BBD A(D0<BBE E(D0D8Dp<$BBE B(D0D8D<dBBB B(D0A8D3D $kBGA GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.data.bss.rodata.cst8.rodata.str1.32.rodata.str1.1.rela.eh_frame.comment @{!1h
&!,!1! >2! N2"9b#]P<l&'u+h
h/y
!k"',
1Hcj?>00[!(0A
kOT6j@BJFF`'N$F7PIP`[@n 3fftwnd.cdestroy_plan_array.LC7.LC3.LC9.LC5fftwnd_measure_runtimefftw_gettimeofday_get_timefftwndfftw_gettimeofday_time_difffftwnd_create_plan_auxfftw_mallocfftwnd_create_plan_specificfftw_create_planfftw_create_plan_specificfftwnd_destroy_planfftw_freefftwnd_fprint_planfwritefprintffftw_fprint_planfftw_bufferedfftwfftwnd_new_plan_arrayfftwnd_create_plans_genericfftw_destroy_planfftwnd_work_sizefftwnd_create_plans_specificfftw2d_create_plan_specificfftw3d_create_plan_specificfftwnd_create_planfftw2d_create_planfftw3d_create_planfftwnd_print_planstdoutfftwnd_auxfftwnd_aux_howmanyfftwnd_oneb
A{,
J:GUUamwog> t
h
@
+
9
i
}
z"MW~"M~9"V+,_};},0q!J p!"m$[Z! `0
Hh@ @``0P`(@h !malloc.o/ 1077312510 14522 10060 100644 3440 `
ELF>H@@
HHHHuHHEHtHfHHHu.H=H=1ffffHHtHHuHfHffffffHSHHu0H=H=Hھ1ffffffffffffHu
t@@AWHAVAUATUHSHH=(H+L%ML$L$L$H LH(A$1L$tfHHuH H$AT$H$1$tHHuH H$AT$H$1$tHHuH H$AT$H$1$tHHuH H$AT$H$1$tHHuH H$AT$H$1$tHHuH LAT$1L$tfffHHuH LAT$ 1L$tHHuH H\$AT$$H$1$tfHHuH)Md$(MH)HĈ[]A\A]A^A_HHuffAWAVAUATIUSHH(H=HӉG
H&LG55HMHcDA uHH}LcBDG t2LÉSwH}LcBDG u=t(tH([]A\A]A^A_LGH)LADGDLMLcCDQ uLA}HfLuLcCD~ t2LÉKwLuLcCD~ u=Au9LǉGGIŉA}bHLmLcCDE t2LÉSwLmLcCDE u)HfLMLcCDQ t4LÉD[AwLMLcCDQ ũ="(LAGE1H&LG55L}HcADO uŃ
HHcH}DGnD$fAE1HLELcCDH t2LÉSwLELcCDH uLLcHCDQrE1AE1HL]HcADK t2LÉSwL]HcADK uHHcL]ADCuD$>AE1HHMHcDq t1LÉSwHMHcDq uσy HHcHuDFD$AE1HH}LcBDG t2LÉSwH}LcBDG u>
HHcLEAD@D$AE1HLMLcCDQ t2LÉSwLMLcCDQ u4 HHcLUADBD$AE1HL]HcADK t2LÉSwL]HcADK u HHcHMDAD$AE1HHuHcD~ t1LÉSwHuHcD~ uσ HHcHuDFW$SAE1HLELcCDH t2LÉSwLELcCDH u HHcLMADA$E1HLuLcCDV t2LÉSwLuLcCDV uHLuHcADF t4LÉDSAwLuHcADF ũ=)LDl$T$D$DG
A@ŉT$$D\$ !
lAtxAtrHDHuXHR(HK\$9u9But$9ruDD$D9BuDL$D9JuDl$D9ju$$D$ \$zDz Z$H+fffLG
L]HcADC uÃ)p1ffLMLcCDQtFDLA
ADlÉD[AwLMLcCDQuEDt$2H}LcBDGtFELA
EFlÉDKAwH}LcBDGuEE5HMHcDqtBE
LDFlÉ{wHMHcDquEDt$ALELcCDHtFELA
EFlÉDSAwLELcCDHuEDt$HuHcD~tEELA
EFlÉDCAwHuHcD~uEDt$L]HcADKtDDA
ADl;LÉswL]HcADKuEDt$LULcCDZtDDA
ADl;LÉKwLULcCDZuEDt$'HMHcDytCELA
EFlÉswHMHcDyuED4$WH}HcDwtEELA
EFlÉDCAwH}HcDwuE0l$Dl$DxDL$DT$L=Dt$(DhDD$$DH$DPt$ Lx(DpD@Hx$p LAAFމH)LADG=D=LULcCDZ uLAAFH&LGLMLcCDQ uLAAFH&LGL}HcADw uyLAAFH&LGHuHcD~ uYLAAFH&LGL]HcADK uNLAAFH&LGH}LcBDG uLAAFH&LGLELcCDH uLAAFH&LGLULcCDZ uLAAFH&LGL]HcADK uffffU1@SHl$(H\$ L\$twLMugfffMR(MtZA9:fffuA9BuA9RfffuE9BuE9JfffuA9JuȋT$0ft&A3UArAJ AR$fff[]1[]Az EB;EAZ$]fH\$Hl$Ld$Ll$Lt$L$H8A $PAEE!Ȩtct^HHu}HR(Htt9*u9BuD9bfffuD9juD9zfffuD9ruDL$@DD$Hl$PDJDB j$H\$Hl$Ld$Ll$ Lt$(L$0H8ÿf0H
$@X(DhDx\$Pt$HD`HH(DpxHp X$fffHH=HuHHW(HH=HuHFFTW2.1.3%dbug in planner (conflicting plan options)
x<}BEB B(A0D8G <\BBB B(D0A8G`$AG$+d@6DGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.str1.1.rodata.str1.32.rela.eh_frame.comment @ +&>1$62E2 + ZPU>xdXwmhX
,1 =G
Q}dlP+6wisdom.cwisdom_listWISDOM_FORMAT_VERSIONemitinput_errorget_inputnext_charfftw_export_wisdomsprintffftw_import_wisdom__ctype_b_locfftw_diefftw_mallocfftw_wisdom_lookupfftw_wisdom_addfftw_forget_wisdomfftw_free(:m{

2Mj~
%@Xd
l
0Lm'/=V*Cemz5Y_kty&.<]x
*MUc 5 G U y
&
G
b
t
9AOp#<U["
5
;
L
R
X
+OwCK[&Lu}
$Bu!&9?KQWz !'39?agm &IOUdi17=LQdjv%
*9@o `Pwisdomio.o/ 1077312511 14522 10060 100644 3016 `
ELF>@@@ Ht
HfffffffffHt
HffffffSHHt$D$D$Hc1HHt0HH$HcT$HH;$Ht
HHH[ffHHtH<$HHfffffffff@ffffffffffffffffffffffH@9HHQHAffffffffH1t HHUnexpected output string length!
x4LmAI l$D GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.data.bss.rodata.str1.32.rela.eh_frame.comment @H h
&,12" FA
PY@(
h (9H0Yt @m$wisdomio.cfile_emitterfile_get_inputemission_counterstring_emitterstring_get_inputfftw_export_wisdom_to_filefftw_export_wisdomfftw_import_wisdom_from_filefftw_import_wisdomfftw_export_wisdom_to_stringfftw_mallocfftw_diefftw_import_wisdom_from_string_IO_putc_IO_getc
)
B
Xfx
0. 8 P@p0putils.o/ 1077312511 14522 10060 100644 11688 `
ELF>@@
H\$Hl$Ld$HHHtH9uHt4Mt:Hu(It$(H}H}H}0H눿H}(H=fffffATUSHw0$fffffH{DctIH[ A̓v[]A\H{DcuHs(HCH{ DctH[(1HSHr0HC ffATHIUSHt3w,$DCL1H[ Hu[]A\fffffDCDC[]L1A\DC[]L1A\fDCL1DCUL1AHsULHHq H[(HDC%fffDCDC[]L1A\fffffffffH8@0HG0fffffffffH\$Ld$HHA8K@0D`HKHXHHLd$H\$HÐH\$Ld$HHA8K@0D`HKHXHHLd$H\$HÐH\$Ld$HHA8K@0D`HKHXHHLd$H\$HÐH\$Hl$Ld$Ll$Lt$HIH(A8A@0AMHAUC0APIULh(HX HPu(H@HH$Ld$Hl$Ll$Lt$ H(LDHEffffffffffH\$Hl$Ld$Ll$Lt$L$IH8A8HAE@0ANHAVD`C0APIVLp(HX HPu.H@HH\$Ld$Hl$Ll$ Lt$(L$0H8LDHEfffffffffH\$Hl$Ld$Ll$Lt$L$HEH8AAIտ8@0HC0HX AD`Lhu.H@HH\$Ld$Hl$Ll$ Lt$(L$0H81DHEfffffffffH\$Hl$Ld$Ll$Lt$L$AH88AIMDL$@0H@t
Du
kDsL{Lc AD$0D$u3HCHHl$Ld$H\$Ll$ Lt$(L$0H8fff1DHCH\$Hl$Ld$Ll$Lt$L$AH8Hӿ8AAEDL$L$@D0D`HX C01\$HDxH0Hp(Dh$@XT$HP4!Ȩu;EHEHH\$Hl$Ld$Ll$ Lt$(L$0H8ÿfGfffffffffSWHʅ҉Wt[H H
[ffffHffffffFHHVH7fHHt/90tfffH@Ht90u9Pu9H4u9Pfffu9H4ufffffUSHHHu
7HHt/SHkʅ҉SuH{ OH
HHuH[]fH8,$W *YYXH8ËOH *YYX$f$XH8fffffDG
DA*Xl$ H(XT$ H8fffDOEA*X5t$H XT$H8Ëw*X%d$(H XT$(H8fffffffH\$Hl$HHHHHt$HHtfO(f.N(v"Wʅ҉WtAHH\$Hl$HHËNHɅɉNuH~ vH
HH Z
Hfffffff@t#~ȅt9~ffffffffffH\$Hl$HHHfF({0tRS4Hs H1H\$Hl$H^H1Hs H1H\$Hl$H3ffHHs H1H\$Hl$HfffffffffH\$Hl$HHHfG(H{0t[S4#Hs H1H\$Hl$HfffffH1Hs H1H\$Hl$HefffHHs H1H\$Hl$Hfffffffffinvalid Rader data pointer
%*sFFTW_RGENERIC %d
%*sFFTW_HC2HC %d
%*sFFTW_HC2REAL %d
%*sFFTW_REAL2HC %d
%*sFFTW_RADER %d
%*sFFTW_GENERIC %d
%*sFFTW_TWIDDLE %d
%*sFFTW_NOTW %d
plan: (cost = %e)
(vectorsize %d)
(vector recursion)
%*splan for size %d convolution:
invalid size for rgeneric codelet
invalid vectorrecurse plan attempted
?@xD?$@x$S $DBAC $lCBGC DOJG OJG OJG $,YJ0$T^G@$^J@$^I@$^G@*A,D\9$tNAAD HD@Q 2S S 4GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.data.bss.rodata.str1.1.rela.rodata.rodata.str1.32.rodata.cst8.rela.eh_frame.comment @x &,12E
@P(M2 ] oHjP+X
y `s
C
" ( . 4 :HVeo* 0OO.OE \q@ 0@9NH
"
2.?FV]putils.cdestroy_treeprint_node.LC15.LC19.LC20.LC18fftw_node_cntfftw_plan_cntfftw_rader_topfftw_freefftw_destroy_twiddlefftw_destroy_plan_internalfftw_diefftw_complete_twiddlefftw_create_twiddlefprintffftw_make_nodefftw_mallocfftw_use_nodefftw_make_node_notwfftw_make_node_real2hcfftw_make_node_hc2realfftw_make_node_twiddlefftw_make_node_hc2hcfftw_make_node_genericfftw_make_node_rgenericfftw_make_planfftw_use_planfftw_make_empty_tablefftw_insertfftw_lookupfftw_destroy_tablefftw_estimate_nodefftw_pick_betterfftw_factorfftw_fprint_planfwritefftw_print_planstdoutfftw_sizeof_fftw_real3MS
5@w
2
D5
<
XU
\
lfr
w
~
JZOgz*{
@L
) 5
? +v + + +
$S
]
/
1!
+^
c/,JI77j I(I0787@`HeP@X``h`pex@P0 ` H p 00 X@0 H0`@x
8rader.o/ 1077312511 14522 10060 100644 6384 `
ELF>8
@@AWAAAVIAUAATUSHIcHHXT$TL$PDD$LLL$@HT$@LD$@HHt$@HBAxT$TN$H4E\W0HO DB4FA$H1D9}WDD$T$PDD$LLcL$8fffIcDIAHILcHcD\FD\A9F\AL$LD$OtJHXH[]A\A]A^A_ffffAWAAAVIAUAATUSHIcHHXT$TL$PDD$LLL$@HT$@IHl$@Ht$@HB}NHD$0$@@GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.data.bss.comment@!@'@,@_5 (fftwf77.c
linuxx86_64/lib/libsfftw.la0000755003427200235140000000116710015476202014351 0ustar jimnamd# libsfftw.la  a libtool library file
# Generated by ltmain.sh  GNU libtool 1.3.3 (1.385.2.181 1999/07/02 15:49:11)
#
# Please DO NOT delete this file!
# It is necessary for linking the library.
# The name that we can dlopen(3).
dlname=''
# Names of this library.
library_names=''
# The name of the static archive.
old_library='libsfftw.a'
# Libraries that this one depends upon.
dependency_libs=' lm'
# Version information for libsfftw.
current=2
age=0
revision=5
# Is this an already installed library?
installed=yes
# Directory that this library needs to be installed in:
libdir='/Projects/namd2/fftw/linuxamd64/lib'
linuxx86_64/lib/libsrfftw.a0000644003427200235140000125716010015476203014364 0ustar jimnamd!
/ 1077312643 0 0 0 3820 `
00((""))22;@;@DDLLYdYdccppzXzX$$ììHHDDMxMxWWbpbpppLL@@PPLLSSYY__g4g4npnpww~~<<δδ00 77ddppȴȴ44!<!<;;`,`,!!!!!!!!!!!!!!!!!OOfftw_real2hc_1_descfftw_real2hc_1fftw_real2hc_2_descfftw_real2hc_2fftw_real2hc_3_descfftw_real2hc_3fftw_real2hc_4_descfftw_real2hc_4fftw_real2hc_5_descfftw_real2hc_5fftw_real2hc_6_descfftw_real2hc_6fftw_real2hc_7_descfftw_real2hc_7fftw_real2hc_8_descfftw_real2hc_8fftw_real2hc_9fftw_real2hc_9_descfftw_real2hc_10fftw_real2hc_10_descfftw_real2hc_11fftw_real2hc_11_descfftw_real2hc_12fftw_real2hc_12_descfftw_real2hc_13fftw_real2hc_13_descfftw_real2hc_14fftw_real2hc_14_descfftw_real2hc_15fftw_real2hc_15_descfftw_real2hc_16fftw_real2hc_16_descfftw_real2hc_32fftw_real2hc_32_descfftw_real2hc_64fftw_real2hc_64_descfftw_real2hc_128fftw_real2hc_128_descfftw_hc2hc_forward_2_descfftw_hc2hc_forward_2fftw_hc2hc_forward_3fftw_hc2hc_forward_3_descfftw_hc2hc_forward_4fftw_hc2hc_forward_4_descfftw_hc2hc_forward_5fftw_hc2hc_forward_5_descfftw_hc2hc_forward_6fftw_hc2hc_forward_6_descfftw_hc2hc_forward_7fftw_hc2hc_forward_7_descfftw_hc2hc_forward_8fftw_hc2hc_forward_8_descfftw_hc2hc_forward_9fftw_hc2hc_forward_9_descfftw_hc2hc_forward_10fftw_hc2hc_forward_10_descfftw_hc2hc_forward_16fftw_hc2hc_forward_16_descfftw_hc2hc_forward_32fftw_hc2hc_forward_32_descfftw_hc2real_1_descfftw_hc2real_1fftw_hc2real_2_descfftw_hc2real_2fftw_hc2real_3_descfftw_hc2real_3fftw_hc2real_4_descfftw_hc2real_4fftw_hc2real_5_descfftw_hc2real_5fftw_hc2real_6_descfftw_hc2real_6fftw_hc2real_7_descfftw_hc2real_7fftw_hc2real_8_descfftw_hc2real_8fftw_hc2real_9fftw_hc2real_9_descfftw_hc2real_10fftw_hc2real_10_descfftw_hc2real_11fftw_hc2real_11_descfftw_hc2real_12fftw_hc2real_12_descfftw_hc2real_13fftw_hc2real_13_descfftw_hc2real_14fftw_hc2real_14_descfftw_hc2real_15fftw_hc2real_15_descfftw_hc2real_16fftw_hc2real_16_descfftw_hc2real_32fftw_hc2real_32_descfftw_hc2real_64fftw_hc2real_64_descfftw_hc2real_128fftw_hc2real_128_descfftw_hc2hc_backward_2_descfftw_hc2hc_backward_2fftw_hc2hc_backward_3fftw_hc2hc_backward_3_descfftw_hc2hc_backward_4fftw_hc2hc_backward_4_descfftw_hc2hc_backward_5fftw_hc2hc_backward_5_descfftw_hc2hc_backward_6fftw_hc2hc_backward_6_descfftw_hc2hc_backward_7fftw_hc2hc_backward_7_descfftw_hc2hc_backward_8fftw_hc2hc_backward_8_descfftw_hc2hc_backward_9fftw_hc2hc_backward_9_descfftw_hc2hc_backward_10fftw_hc2hc_backward_10_descfftw_hc2hc_backward_16fftw_hc2hc_backward_16_descfftw_hc2hc_backward_32fftw_hc2hc_backward_32_descrfftw_configrfftw_plan_hookrfftw_create_plan_specificrfftw_create_planrfftw_destroy_planrfftw_fprint_planrfftw_print_planrfftw_executor_simplerfftw_strided_copyrfftwrfftw_onerfftw_hc2crfftw_c2hcrfftw_real2c_auxrfftw_c2real_auxrfftw_real2c_overlap_auxrfftw_c2real_overlap_auxrfftwnd_create_plan_specificrfftwnd_destroy_planrfftwnd_real2c_aux_howmanyrfftwnd_c2real_aux_howmanyrfftwnd_real_to_complexrfftwnd_real2c_auxrfftwnd_complex_to_realrfftwnd_c2real_auxrfftw2d_create_plan_specificrfftw3d_create_plan_specificrfftwnd_create_planrfftw2d_create_planrfftw3d_create_planrfftwnd_fprint_planrfftwnd_print_planrfftwnd_one_real_to_complexrfftwnd_one_complex_to_realfftw_hc2hc_forward_genericfftw_hc2hc_backward_genericfrc_1.o/ 1077312512 14522 10060 100644 1456 `
ELF>H@@ fftw_real2hc_1xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@&`0 !h0
,12E0@
OXH 8, 0frc_1.cfftw_real2hc_1_descfftw_real2hc_1 frc_2.o/ 1077312512 14522 10060 100644 1488 `
ELF>h@@ HcIc(X\.fftw_real2hc_2x$GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@$&0 !0
,12E0@
OXh X, 0$frc_2.cfftw_real2hc_2_descfftw_real2hc_2 frc_3.o/ 1077312513 14522 10060 100644 1816 `
ELF>@@LcBIcB4'(X(\Y5YX\2R0M\7e 8
XB
03Rfrc_3.cK866025403K500000000fftw_real2hc_3_descfftw_real2hc_30 frc_4.o/ 1077312513 14522 10060 100644 1768 `
ELF>@@LcBH@@LcDFMIB?y?qxs?fftw_real2hc_5xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rodata.cst16.rela.eh_frame.comment @x
+ 0 &x0
1P6P>2`Mp`0[
js ] * 5:0Nfrc_5.cK250000000K559016994K587785252K951056516.LC1fftw_real2hc_5_descfftw_real2hc_5;H
frc_6.o/ 1077312513 14522 10060 100644 2152 `
ELF>h@@LcDO[B,KDBIcMD2xM`0[P
js(h
G $08frc_6.cK500000000K866025403.LC1fftw_real2hc_6_descfftw_real2hc_6P frc_7.o/ 1077312513 14522 10060 100644 2384 `
ELF>@@LcFO[Bf??&>&H?y?fftw_real2hc_7xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @x+0 & 016>2(R80M8 \hep
n *5@
K0_frc_7.cK222520933K900968867K623489801K433883739K781831482K974927912fftw_real2hc_7_descfftw_real2hc_7M frc_8.o/ 1077312513 14522 10060 100644 1976 `
ELF>@@LcDMFIKIcB,NHIM)E(B2R0M\e
7
0(#frc_8.cK707106781fftw_real2hc_8_descfftw_real2hc_8 frc_9.o/ 1077312513 14522 10060 100644 3176 `
ELF>0@@LcDOF4/IcF,DD$ME(IDT$BO[E(F
DXA\F,MID$FEXNEYE(M)EXA(A(E\FE\FUP?p?H>UZ?1>?}D?\?1>$?)?׳]??fftw_real2hc_9xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
P+0 & 010608>2hRx0MP\eX
*5@KVa l$w(,04
0frc_9.cK342020143K813797681K939692620K296198132K852868531K173648177K556670399K766044443K984807753K150383733K642787609K663413948K866025403K500000000fftw_real2hc_9fftw_real2hc_9_desc0T(a ,%2$_gu&Ud frc_10.o/ 1077312514 14522 10060 100644 2552 `
ELF>h@@HcDLII,FLFLB?fftw_real2hc_10xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
+@0 & 0
1p6p>L2`0[
js( `
+ 6;K0frc_10.cK587785252K951056516K250000000K559016994.LC0fftw_real2hc_10fftw_real2hc_10_desc%Xm
frc_11.o/ 1077312514 14522 10060 100644 3256 `
ELF>h@@HcSLHHHDEXEXD(EYD\(AYD\E\D(EYDD(DT$AYEXd$EYXL$DYYXL$EXD(EYY$E\DD$AXDYY\$D\(AYAXAYD\d$[YAYD$AXDXAXDXA\D\A\D\\D\$D'?>Uu?G>d\W?d}?h?@?>pg
?xA?fftw_real2hc_11xDGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @+@0 &p01p6p(>2R8M\e
+6ALWb m$
x0frc_11.cK654860733K142314838K959492973K415415013K841253532K989821441K909631995K281732556K540640817K755749574fftw_real2hc_11fftw_real2hc_11_descN /Cv frc_12.o/ 1077312514 14522 10060 100644 2448 `
ELF>@@HcD'IIHIIFF<D4LLE(A(A(I)FLIEXD(D(BBE\A,DAXDY(AXE\D4E\E(IMcDYDXBL2`0[x
jsHh
J
%50frc_12.cK866025403K500000000.LC0fftw_real2hc_12fftw_real2hc_12_desc4y
frc_13.o/ 1077312514 14522 10060 100644 4240 `
ELF>H@@HcDILIID5BLLHDL$<HB4HD(FD(LD\XI)4B,HA(D(D?,=,>X><֙>:>,>@׳?# >2>
><ḙ>dQ2>l<?׳]??fftw_real2hc_13xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @8
+0 &H0
16P>`L2p`0[x
js
+6ALWb m$x(,048<@DHL 0frc_13.cK083333333K075902986K251768516K503537032K113854479K265966249K387390585K300462606K258260390K132983124K2_000000000K1_732050807K156891391K256247671K011599105K300238635K174138601K575140729K866025403K500000000.LC0fftw_real2hc_13fftw_real2hc_13_descHbDD<85@L4f0z,$((6 Ud frc_14.o/ 1077312514 14522 10060 100644 3216 `
ELF>@@HcS,LIID7LFH)LIID$HHE(B4HE\D?&>y?&H?fftw_real2hc_14xDGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
+`0 &H0
16>L2`8[x
j's` (v
+6A LQa0frc_14.cK900968867K222520933K623489801K433883739K974927912K781831482.LC0fftw_real2hc_14fftw_real2hc_14_desc^9
frc_15.o/ 1077312514 14522 10060 100644 3464 `
ELF>@@Hc?L%HLIFF4(LD,A(I)Hk4FAXE\F$H4L?P?R?>?y?qxs?>׳]>׳]??fftw_real2hc_15x
GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
8
+`0 &@
0
16(>L2`0[p
j/sh (
+6ALWb m$ x}
0frc_15.cK509036960K823639103K250000000K559016994K587785252K951056516K484122918K216506350K866025403K500000000.LC0fftw_real2hc_15fftw_real2hc_15_desc *f frc_16.o/ 1077312515 14522 10060 100644 2768 `
ELF>@@HcATIL$IISHBMIIIBB4LI)HI)D(F4Hk4D,\DXDA(Dt$E(4D$EXE((A\D
\X
A(YDXD\d$EX%D(Y(DYDXT$AY\B,DT$D$(E(D\DXBAXA\D(A(D$A\EXE(XA\EXYYBA,IL$BD<IcD(IIIHD\IHXH)(A\AYAXE(EYE(DYYEX(AXD(XD\A(E\X\E(FD\\DXAXD\BMcLDO$RHOA(D\d$Y=HDD$D\l$l$DY5DX$\T$DX\d$E(A(D$D\X\\$AXDX$(BAXD\\$XE\D(\F4DE\A(D$AXA\DEXJfftw_real2hc_16x$jELGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @j +0 &
016>2R@M
\PoeXP
P
+j;0frc_16.cK707106781K923879532K382683432fftw_real2hc_16fftw_real2hc_16_desckh frc_32.o/ 1077312515 14522 10060 100644 4784 `
ELF>8@@AWHcɸ\I
AVIMcMcAUIIATUSHF/HL,I,MF$?ID?F7ML4D(IA(MB4IA(F,I)LAXIAXF4MEXII)A\I)LE\IH(D,/HH(HA(E(ݸLLD$lD\FDXDL)LHYD>Y=A(E(DD$AXE\DYDd$EXYB(D
\T$JD(Yd$IDYM)E\DL$EXDT$DXA(EYDY\$YA(D\A(\A(AXAXE\D(\DXDX\4D$AX=FE\D(E(l$EXt$D\\$D\X\$DXT$F\T$FDT$BF{?9?1T?>^l?5?fftw_real2hc_32x4 BUL I(A0A8GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @ +
0 &h010
60
>2L
R`
PM\
e
h
+6AL
W g0frc_32.cK195090322K980785280K555570233K831469612K382683432K923879532K707106781fftw_real2hc_32fftw_real2hc_32_desc'qCQ?
frc_64.o/ 1077312515 14522 10060 100644 9312 `
ELF> @@AWHcMcHMcAVIIAUATUHHSHH/DH)F7II)(E(ME(IHEXE\F/L,IMMIIF,'B<L$IIE(MBID\F<A(D(IIA(MA\I)AXL$EXDX((LAXA(Y%H)D\DY\A\D,AXE\D\$DXE($D$D(D$FLiD\D$AXEXX(FO4@A(LAXHY=E\DYD(EY\EYDXAXD\,AXJ(D4BD(AYF"ID$EYD\D$LEYM)d$D(L$Lt$ L)A\\t$0M)D(AYDYd$%$X$D(D(D\L$(EXXL$$Dl$(D\l$=E\A\DXEYDXDt$T$0XT$ D$D((DYYYDYEXD(DY(YYE\Dl$DD\$X$\\$L$x\$D$(T$(YY$YX$Y$XL$xX(\Y(Yt$YYA(AXXXA\(X\\B>OD$DXt$TLEYHD>EXEYD\$hD(A(DYA(AXE\D$DX$PE\DX(E\DXd$AYA(E(E(\A(AXE\XA\DXA\\XXA\BE\MBAXDL$DXX\$A\((IEXXXL\E(I\E\EXF$&DL4:,*BB
T$,HLA\(X\BH[]A\A]A^A_@Z>a?1>t?9?1T?m~?6=E?g"?{?G>>^l?5?fftw_real2hc_64x<tBNI B(A0H8OGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @t 0+0 &$016<>2,R@XMH$\ep
+6ALWb m$x(,048
t0frc_64.cK471396736K881921264K290284677K956940335K555570233K831469612K995184726K098017140K773010453K634393284K980785280K195090322K382683432K923879532K707106781fftw_real2hc_64fftw_real2hc_64_desc44a4i40w4,4@4s444%4X4y 4 4
44(:$Z4h4
6
l
4[4 frc_128.o/ 1077312516 14522 10060 100644 23672 `
ELF>C@@AWHcIAVIAUATUSHHHF<DI)HDE(IHI)A(E(MIHAXHE\F'L$ILMHID,/F$?H,IIA(IF?IE\B4AXIA(IE(N,A(L$(ID\E\EXF,/XIE(IEXE\DY5DYAX(X(E(E\EXAXE\XD$D$\F$A\$\D$I)$E($$EX$E\F,/LiA(A(B4/IIB,/LiPXD\(F/XLiD\AXA\(FDXM\I)AXLE\HF<HD$PHHHD$8DHD,Y$D=A(DD$ DL$ DY$Y$D$DY$DX$D$$ DX$DY$$DY$X$Y$l$ XY$$E\D$A(D(E(EXD\$,D\X$DXD\Dd$4D$0$<D$X$$DX$XA(XD(AXE\D$8DX$ A\D$(XD$L$,($\$$DX\5EXD\$(EY(YDYAYA\D(AYDYD(D(EYDYEXD
DYE\D(DY$(X$EXD$D\$lX\$lAYYY%DYAYX\l$4AXDAXDY(XD(D\\D\XDD\t$4LT$(,\T$,l$,Xl$(H)III)IHi(D(X\A(<(B(HiAXD\t$$AXD\$AX\$DXD\l$$\l$0(DA\BDX$0A\N$I)EXA(D$D\$\D(BA(F4IEXIXN!HD\HAXID$I)E\B4$FILiټA\EXE(FDXME(I)DXA\DD$D=D\FID$E(D=DY$HiǼEYAYHEXD,Dt$DY$HiA(D\A\EX$$$D$\$<\$Y$D$D\$EY$\$DL$DY$$ \$8$(\$A(\A\D$AXD$\EYt$$(l$$DX\$,EXX%A\(D(X$hYD\$hDXD$(D(Y,$$xDYA\D(AYDY
D(DXDY=AYDYA\DDY$\$(EXD$x\DX(AYD
YY,$EYYXAY\DT$AXD
DY$EXA(D\(X\\DXD$\$F\\$t$Hk\Xt$AXD\d$I(D(X\(AXD\HiA(DX\A(\t$HiA\FEXID(D(HiǤDX\(l$$Hk\X\$\A\Y$D$Dd$Hi(EXD$A(A\EXHD$HD$Hkd$Hi<A(HiAXE\DXA\AXD$DX$\FIDY$<HiǜE\HkdDl$D$,I$DX\$AXL$D\$X$Y$D$DY$$Y$D$DY$$@\$H$Y$D$DY$D$\A\$\AXD$\D\$D$HX$DDYD(X$@D$DD$`DY$DXAYDYd$X\d$`AXDYD$DY$DXt$t$dYD\$Y\$`E\D\$\D(AXDYDD$dEXD\$$\$XX$XDYE\$dX$TDd$dD\\$XDYYY$dD\d$`Y$T\$dX$\YYT$\YYL$X\X(AXD\T$(AXA\E(D\t$(X\(BA(A(A\EXX(E(DXA\D(d$E\AXD\A(A\B4:AXF$*XF"BDd$L\$HDXd$B6\$DL$Dl$IA(B,l$LiE\HA(Hd$8LiѰLt$8Hd$PAXHd$@L$PDT$\D\T$DXXA\B4.Ll$@EXD$.B2E(B<A((MLiIMHiAXM)D\LIA\M)LEXM)B<:IJFM).IK,F.M)LD$DX$D$DX$$X\$4$<\$PD$LD\$l$t\$DE(D
$t$lX$DEXYX$LE\Yd$EYDD$DYt$\$ D\$ IiDYAYDYDYY=DX$XX$4\$PEXX$<D5Mid$d$DYDYYYE\D\$ DL$X\$DYA\\$DXYL$ Y5=$D$$D$$$DYX$\Yt$5YYDYY$A\D$DXDYY$A(DX(\(AXD\XA\D$DX$L$AXD\(L$AXD\l$AXD\t$(\XBN4(BM)\XA(((AXD\BD4Dt$IiMiEXD\\$AXD\A(A\EXB(F4Mi,A\ٸhF,AXAXE(DX((A\A\AXE\X\LBMEXDLD$0D$\$LDl$E(Dl$DY(E(AYEYE(EYDYYEXD$TD\D\$8MAhIiDD$E(DYAYEYDYE\E(HtDY$MiYDXAYDY\5YAXD($DYYEXD5DY%E\D$DYD\$YA(X\AXD$$$\$$YY$YY$XA(\XD(D\X$\$A\E(DT$D(DXA\D\Xl$l$Xl$(\XBT$OA\B,DXT$(A(XAX\E\DT$D\T$
IiBA(OAXB,E\D*A(DL$(\l$\Xd$AXIiDXB.MB4&D(t$EX(A(M\AXDXD\K@X\DD4:F:LOIiشE\B,2HEXA,IiLMiD*LB$*ATMiB"MD$D$,Dt$\$4DY$DDY$D$DY$Y$DT$DY$D$DY$DY$$EXD$D\$DY$D\$A\$\$D$D\$$(\$0A(IATD(MME\D((\$DXIi٬AXA\EXD(HE\$DX$E\t$DX$$\D\$E\DXXDL$%E(M(DYD(YAYIiIiA\D(DY
D(DXDY=YYA\DDYDX$\$$(X$`\$`\$D$$Y\$ $pAX\X$pDYt$A(DYYl$A\DAXDY\$DL$AXD\d$DYYL$(EXDDY\$D\(X\t$Xt$\XB>A(MiA\,.lEXD(EX(A(D\A(\d$X\(AXE\B,"E(A(:(D<
LEXE\E(MiDXAXA\F4>F$.D(HIiٔXX\E\AX\E\F$&B4,:<BT$l\T$IiȔL(AXA\BH[]A\A]A^A_x>Sx?=?[??M?@>:}?Z>a?t?1>> q?>kg?g"?E?J+?=?0H=?m~?6=9?1T?G>{?>^l?5?fftw_real2hc_128x<ABHF B(A0A8NGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @AK8+`A0 &0\01A6A>2BR BXM`\\xBBeF
( pJ!,7BMXc n$y(,048<@DHLPTX\`d)h4l?pJtUx
`Aq0frc_128.cK242980179K970031253K514102744K857728610K595699304K803207531K146730474K989176509K471396736K881921264K956940335K290284677K336889853K941544065K427555093K903989293K634393284K773010453K671558954K740951125K049067674K998795456K995184726K098017140K555570233K831469612K195090322K980785280K382683432K923879532K707106781fftw_real2hc_128fftw_real2hc_128_descttUtft\`hdpl\`d
th0lGp}tplplll!p.p~llIpapil{ttppl,tKt t t8
t
t
t
l
ppl0l=lPt^hoppd5dF`N`Wd`\hhu`}\\h\dh
`tt;pUh]dplyld`hp\\>`Vlppl.lltt$pEpttpYlpl7pttlplttttlpl+pKplotmh\d$`"T"X"T"T##T#L_$P$D$H$H*%HP%H$'@G'<(8(4),.)0F)0)0)0e0T0T1T1T1d1h4 4$44(35\5 5 5 5`A99:3:<:::< < = I= H>_>>>>f??%( fhf_2.o/ 1077312516 14522 10060 100644 2112 `
ELF>h@@LcBMcNNJ(M)\XB9DHcMB4EDDNAH8A(E(EY(DYY(EYEXA\A\DX\XAWA,8BLE M)9u9tBA/fftw_hc2hc_forward_2xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rodata.cst16.rela.eh_frame.comment @
+@0 &H
1p6p>2tM`0[(
js(P xK 06fhf_2.ctwiddle_order.LC1fftw_hc2hc_forward_2_descfftw_hc2hc_forward_2J
( fhf_3.o/ 1077312516 14522 10060 100644 2560 `
ELF>@@LcSABB4KID(H'IcXA(DL\(HcYXAY\B<'H<4L)A94D%ILIMD.AB$nE(D~BL2`8[
jsX a 2G0fhf_3.cK866025403K500000000twiddle_order.LC0fftw_hc2hc_forward_3fftw_hc2hc_forward_3_desc!B
( fhf_4.o/ 1077312516 14522 10060 100644 2688 `
ELF>p@@AVLcAD%LAUHAH8DATAKIHUL,SIcB`L2p`P[h
js0h
V "'<0fhf_4.cK707106781twiddle_order.LC0fftw_hc2hc_forward_4fftw_hc2hc_forward_4_descV
( fhf_5.o/ 1077312517 14522 10060 100644 3552 `
ELF>@@AWDAAVAAUATUHSDT$DT$D$LcL$A(DT$T$F$MIFBFE4D(A(/EY$EYDfDvAYAY4E(DDYElAXDYE(DYfA\DYD^EX(YE(YDYVDYE\vFH AXD\D((DYAYY(AYE(A\X\Xd$D(D(YYL$E\AXD$E\AXD(D\$D(AXEYE\DX\(YX\Y=AXD$DY$DXYT$DD(DT$D\A(DYt$EYAXD(EXD\D\L$E\A(AYDY\$\A(DXd$Yd$EXD\AE\A\F$EXE(XBE\EEX(AXWl$D\,DWt$DD4/LD<L)E9lE9t[]A\A]A^A_F$OILFHF447\$A(Hc\$A\D($E\l$AXD((AXEXYYt$A\YDXYL$AYDYd$D(F<X(L$\Dd$E\WXDl$\ڀt$DL$'B*D[]A\A]A^A_q>?y?qxs?fftw_hc2hc_forward_5x4BYM B(A0H8GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
+`0 &
H
16 >L2`P[
j(Gs
0w *5 CH]0fhf_5.cK250000000K559016994K587785252K951056516twiddle_order.LC0fftw_hc2hc_forward_5fftw_hc2hc_forward_5_descAt( fhf_6.o/ 1077312517 14522 10060 100644 3792 `
ELF>0@@AWLcOI5AVAAUJO,ATJN$ULHSF L20`HP[
js
pa 2tG0fhf_6.cK500000000K866025403twiddle_order.LC0fftw_hc2hc_forward_6fftw_hc2hc_forward_6_desc
!9N\
( fhf_7.o/ 1077312517 14522 10060 100644 4728 `
ELF>@@@AWD%DIAV
E(AUATUSDT$Dd$D\$LcT$\$DD$L$$ԉL$HDL$B4Of??&>y?&H?fftw_hc2hc_forward_7x4n B[N J(A0A8GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @n p
+ 0 &H
1 6 8>0
L2@
`X
P[`
j
s *5@K Y^n s0fhf_7.cK222520933K900968867K623489801K433883739K974927912K781831482twiddle_order.LC0fftw_hc2hc_forward_7fftw_hc2hc_forward_7_desc!/( fhf_8.o/ 1077312517 14522 10060 100644 4280 `
ELF>p @@AWIAAVAUATUSDT$LcL$A(MJ,O4IIFI;L)KM^l?5?fftw_hc2hc_forward_8x4BLB B(A0A8GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @8
+0 &XH
1060,>`L2p`P[
js0
l * 8=R0fhf_8.cK382683432K923879532K707106781twiddle_order.LC0fftw_hc2hc_forward_8fftw_hc2hc_forward_8_desc
bs4qz\
( fhf_9.o/ 1077312517 14522 10060 100644 7536 `
ELF>@@AWHMcAVAUATUSHH`T$T=LcT$TDD$4L$P$DDl$DOFK,RN$O4N,FE(MLl$HME(IIM)F4/NB,JLL$8L<L4EXIE\D(FMLLEXDY(EXE\A(D$D\l$4HJAXD\B(AYAXDY$Dl$0\AXA\E(DXYDYA(A$%A\(DXYAYD?D=D$,T$TY$DDEYDEYHcLEYD\=D\%IIYA\I)(AYE(DYL$,AYAXA(DD\DY$4DXEY(DL$,DXAYDY5EX5AXYYD\XYT$DDXEXDYd$4BL$0D\D\AXDYD$DAYDYF<D\E\E\D\E\FJ<D$D\D\t$0D4
;L$PNIkLt$HT$ILLd$D5MML$L$HH$LID)t$IIMIHHD$HLHT$HT$8H,$DFDv(DV,F\
A(Hl$Dl$4E(D\$(T$D4/Hl$D^BL
YHl$A(DYA(YDDt$E(EXDYl$DE\DnEXE\D(YDYDL$DNA(DYY4DXA(DYD\YV(YYN0AXDn4(H@\A(AYDYA(YY(\(DXX\AXYd$4A\XYT$4Yl$D(D\A(XY\$DE(D\DX(D\(AXA\AXYT$4D\'Xd$YAXD\(X\'5(Hl$DX\$(D5XDYd$4\Yt$EYDY$/Hl$A(A(BL
Hl$L$DYAXDDY\A)EX(DA\Dd$DXd$$XEYA(DY=WT$BD
DXHl$5A(YAX/=E\Y$T$XT$ DY\$4A\XY\$DA\(B$D\\YL$4XE((D\DXXG
F$7A,H,$Yt$DD%D5=Y$D$EYEYD\$$DY\5AYD
DYL$AYEXDYD(A(A(\A\EXE\XDWl$D(EXXDYD$4Y\$DDXD,A\Dl$ D\l$A\Yt$4GB$D(Yl$DD\EXD(A(A(A\AXD\BT
Hl$EXBL
D\Hl$DWT$DWl$F\
J,I);L$PF?F,'J<';L$PtH`[]A\A]A^A_ORDLJMF,HFL)D4IA(O,A(LE(Dt$4LAXDL$EXDd$4DA\(Yd$DT$DYEYE\t$F,IAY(D$Dd$Dt$D\D5Dd$IE(EYDT$EYDX$D$D=A(AYXl$AY\A(l$l$A\D
A(AY\$AYYYXA(L$d$
D(DYEYA\DXd$DT$Xl$l$\$TFB$B,Lcd$TA(DYD(DYXYAYD\A(EYYEXE(DYDY\(AYEXYD(YEY\AXT$Xl$AXDL$E\D\$AXEXEXDDXd$XD\$D\D\d$DY\$4EXA\DYd$DGEXEXDF$AYDXDd$DDXD$(\d$Xt$EYEYDXd$DW%D\AYl$Xd$AYD\D\L$DDD$\X\$AYAYXD\B$IID\F E!FD\$D$DDXt$T$EYDXT$AYEYXE\FH`[]A\A]A^A_ >׳>}??б>?D/?\?D>UP?p?H>UZ?1>?}D?\?1>$?)?׳]??fftw_hc2hc_forward_9x<BLB B(A0A8KGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
+0 &H
16 >L2`X[X
j ?sx`" E ,9DQ\i t$(,048<@DHLPT` +0fhf_9.cK250000000K433012701K1_532088886K1_879385241K347296355K1_285575219K684040286K1_969615506K342020143K813797681K939692620K296198132K852868531K173648177K556670399K766044443K984807753K150383733K642787609K663413948K866025403K500000000twiddle_order.LC0fftw_hc2hc_forward_9fftw_hc2hc_forward_9_desc#L/Pw@DH4<8,B0c(} 0<$n <8DD70`<~80! 0* <2 $L 0a <m { $"/&
y
"(` fhf_10.o/ 1077312518 14522 10060 100644 6184 `
ELF>@@AWLcHNIMcAVO4M)AUN<MIATO$UJ4J,SK[Hp
F$Hl$PLD/HB,T$dA\FDX$A(FL$`\D<\$\L$HLl$@DXHL<,/N4Dd$XA(F$I((A\AXE(EXE\F/XL,XE(E(E\EXE(EXEXE\E\E(DXD\DY5AYAXE(DX\A(A(D\X(DYA\EXBAYLB? fftw_hc2hc_forward_10x<BZI Q(E0M8HGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @0
+
0 &H
10
6@
D >
L2
`
X[
j/sh z
+6 $ DI_0fhf_10.cK587785252K951056516K250000000K559016994twiddle_order.LC0fftw_hc2hc_forward_10fftw_hc2hc_forward_10_descTaN1_r G %C( fhf_16.o/ 1077312518 14522 10060 100644 9408 `
ELF>@@AWMcAVAUA4ATUSHH$$Hc$D7HIIHII7H$hHtmB47II9LHLL$DH(DH$`MB1>>=?@5?^l?>
fftw_hc2hc_forward_16x<BEB H(A0A8JGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
+@0 &`$H
1p6 >L2`(X[$
js(
+6CP[f q@< 0fhf_16.cK277785116K415734806K490392640K097545161K1_414213562K2_000000000K707106781K923879532K382683432twiddle_order.LC0fftw_hc2hc_forward_16fftw_hc2hc_forward_16_desc!?{@
b
.<T!6(@ fhf_32.o/ 1077312519 14522 10060 100644 21856 `
ELF>?@@AWMcAVAUATUSHHD
$$Lc$D'LMNHIL,H$XKvBXHAdD\NI=H$L$H$H$$ML$(DYD$(AYDDY
TMM$MA(LH\B4D\EXX$BAYL$DYD$D(\DXYYE(>Zq>>g>>m>6H=9>1>=>C?^??@G>{?9?1T?>^l?5?
fftw_hc2hc_forward_32x<e=BEB B(A0A8J
GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @e=Hx
+=0 &UH
1=6> >>L2>`?X[HU
j`??sCx# 0GQ
+6ALWb m$x(,048<@DHLPTX
` e=60fhf_32.cK145142338K478470167K235698368K440960632K317196642K386505226K497592363K049008570K277785116K415734806K097545161K490392640K765366864K1_847759065K1_414213562K2_000000000K195090322K980785280K555570233K831469612K382683432K923879532K707106781twiddle_order.LC0fftw_hc2hc_forward_32fftw_hc2hc_forward_32_descT@TT"TPP<LPP2TQTET\TPPT$PP6T H D D H D$
H
Hh
Du<~@@<<@<)@Z
!TTiTT2T T= Tk T!T"T#T_#Tp#T#P$T$T$T$T$P$P$P%P%P%P&P'P'T2(T;(P(P(P(H(@(<h)Dt)H)D)<)@)H*<$*D*D?*Hs*@*@*<,P1,P,TTD;PSHbP<D@.@.Ha.<o.@}.@.<.<.H.D.D/Hx1P1T1T1P1P&2P282,34)304$4(4$45 5 ?5$P5 5$6 778b9e::;!<<#(` fcr_1.o/ 1077312519 14522 10060 100644 1456 `
ELF>H@@
%fftw_hc2real_1xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@&`0 !h0
,12E0@
OXH 8, 0fcr_1.cfftw_hc2real_1_descfftw_hc2real_1 fcr_2.o/ 1077312519 14522 10060 100644 1488 `
ELF>h@@ HcIc(X\;fftw_hc2real_2x$GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.eh_frame.comment@$&0 !0
,12E0@
OXh X, 0$fcr_2.cfftw_hc2real_2_descfftw_hc2real_2 fcr_3.o/ 1077312519 14522 10060 100644 1816 `
ELF>@@Hc,McIc(BY\Y(XX\$Q@׳?fftw_hc2real_3xMGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @M0+0 &016>2R0M\7e 8
XF
#07Mfcr_3.cK2_000000000K1_732050807fftw_hc2real_3_descfftw_hc2real_3+ fcr_4.o/ 1077312519 14522 10060 100644 1792 `
ELF>@@/Hc2R0M\8We@
`9
0*afcr_4.cK2_000000000fftw_hc2real_4_descfftw_hc2real_4 fcr_5.o/ 1077312519 14522 10060 100644 2144 `
ELF>0@@Hc5McDIcDHI(D%=AXE(F4A\F,YE(YHYD(EYHD\EYAY(EYDXAXD\E\AXD(A(\XA\EX$2D}@??qx?y?fftw_hc2real_5xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @x+ 0 &01P6P>2dRx0MH\e
0k #.;
H0\fcr_5.cK2_000000000K1_118033988K500000000K1_902113032K1_175570504fftw_hc2real_5_descfftw_hc2real_55Wj fcr_6.o/ 1077312520 14522 10060 100644 1944 `
ELF> @@LcDB2XRh0M\e8
F
#07fcr_6.cK2_000000000K1_732050807fftw_hc2real_6_descfftw_hc2real_6` fcr_7.o/ 1077312520 14522 10060 100644 2496 `
ELF>@@McD5DK[B$D$E(A(DDYAYFE(HcA(LvE(AYD\DYEY5EYEYDD\(A(EYD'YEXB$D(IcH?&^??&?fftw_hc2real_7xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @+0 &x 01060>2LR`0M \e
H #.;FS
`0tfcr_7.cK2_000000000K1_801937735K445041867K1_246979603K867767478K1_949855824K1_563662964fftw_hc2real_7_descfftw_hc2real_72qL
fcr_8.o/ 1077312520 14522 10060 100644 2040 `
ELF>@@LcDL%HMc4E(D(K[FY,F$DXDD\(B4ORBY2R0M\e8
8F
#07<fcr_8.cK1_414213562K2_000000000fftw_hc2real_8_descfftw_hc2real_8 fcr_9.o/ 1077312520 14522 10060 100644 2936 `
ELF>@@McO[D?D%D(F4FYE(LcE(KRLHB<LHDIcD\DYL(HA(I)DEXB$E(HHD\AXEXE\FXEYLID\AYHDHA(A(XAYEYD\DXA\D5A(AXYE\E(DY\DXAYDYEXD\DYA(DDA(DXDY\%AYB
F,DA\AYDYYXEXD\A(\A\EYDY((EXAXA\EXXD\B<4:D<2 \?1>1>U?$?}D?թ???׳]?@׳?fftw_hc2real_9x(GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @(
+0 &00160>2R0M`\ ?e((
P *7BMZg r$}(,
(0fcr_9.cK984807753K173648177K300767466K1_705737063K642787609K766044443K1_326827896K1_113340798K500000000K866025403K2_000000000K1_732050807fftw_hc2real_9fftw_hc2real_9_desc($
'Gh fcr_10.o/ 1077312520 14522 10060 100644 2464 `
ELF>p@@LcDOFDB4E(McMLF4HD\IDXB<4K[FK4RD(E(E\AXD(XD\BE\IcEXLH4(LIHH\I)HXD(A\EXD(A\EXAYDAYDA(EYAYA(YEXAXB,(YYAY\X5DYAYE\D\E(D\AXE(DXD\F$FD(XD\A(EYAYD$DD(AYA(EY\AXAXA\((\X\XH$
B:
?qx?y?@?fftw_hc2real_10xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @x+`0 &X 016>2R0M \e
pn
"/<
IY0fcr_10.cK500000000K1_902113032K1_175570504K2_000000000K1_118033988fftw_hc2real_10fftw_hc2real_10_desc(H fcr_11.o/ 1077312520 14522 10060 100644 3424 `
ELF>@@DMcFMIKRLcE(B4EYOFGT?d\?@??x?d??pg?fftw_hc2real_11xQGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @Q+0 &
016,>2R0MH
\@_eH
X
$1<GT_l y$(
Q0fcr_11.cK2_000000000K1_918985947K1_309721467K284629676K830830026K1_682507065K563465113K1_511499148K1_979642883K1_819263990K1_081281634fftw_hc2real_11fftw_hc2real_11_desc$_ 1x fcr_12.o/ 1077312521 14522 10060 100644 2424 `
ELF>@@LcMcKF
O[DK@B,4D(KE('EXE\BDLHDYB2R0M` \e8
8I
$,40fcr_12.cK1_732050807K2_000000000fftw_hc2real_12fftw_hc2real_12_descJj? fcr_13.o/ 1077312521 14522 10060 100644 4232 `
ELF>H@@McD=O[LHB,>:?s>?*><??dQ>l# >ḙ>
><׳?@fftw_hc2real_13xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
+0 &@01060L>2R0Mp\e
8CNYd o$z(,048<@DH
0fcr_13.cK531932498K774781170K1_007074065K227708958K265966249K516520780K151805972K503537032K166666666K600925212K500000000K348277202K1_150281458K256247671K156891391K300238635K011599105K1_732050807K2_000000000fftw_hc2real_13fftw_hc2real_13_descDF<aDn@@84:0L,Z$q(8 jrDD@ DA@VDoD fcr_14.o/ 1077312521 14522 10060 100644 3136 `
ELF>@@LcD/NB4McFM)E(FK@OF4D4EXBOE\D
B,ORIDl$F<D(DL$BXD$D$D\E(D
t$D\XT$B4IA((XT$\,AX,(\$AXA\F4E\FX$A(AXAYD\$FMcNLMA(LMEXL)A\DHLLHAYEYD$AX$K4@%(YAXDA(YX(AYAX\=(AY\(\XA(AYB(:K<Y(Yl$AYDYXL$AXYAY\A(AY\(AYEY\(X\L$BYL$I(IAYD\$DX\$DX\$\(AYD$\t$EYD\$AXDXT$EYAYEYDYL$A\Dt$DYA\DXt$Dl$DYl$D(XD\D\t$F$Y,Dl$DT$Dd$YAXDYYd$EYDYD$D\l$EXDT$AXYY\$A(Xl$DYY$D\X\$A\A\\EXBT$YT$A\A\F4I((\\XA\
,\XBC>??&^??&?@fftw_hc2real_14x1GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @1P+0 &016>2R0M(\/e
"/:GT
a1q0fcr_14.cK445041867K1_801937735K1_246979603K867767478K1_949855824K1_563662964K2_000000000fftw_hc2real_14fftw_hc2real_14_desc^c
fcr_15.o/ 1077312521 14522 10060 100644 3200 `
ELF>@@HcMcD7LOD
HFFYE(H)=O@E\DMc%O@(K4D(MYIL\DY,DXL(HH\Dl$E(DYAXD\d$l$D\Yl$YDYd$XDXYA(t$EX(DT$A(AY\E(DX\EX(\XE\$(AXA\$\$T$DAYDYt$DD$A(DL$YL$AXAYAYE\D5A(EYE(AY\\$E\EXD\$XA\DXd$A(E(\DXA(\$D\B$DXO(F2R 0Mh\PoeX
$1<GT
azq0fcr_15.cK1_118033988K1_902113032K1_175570504K500000000K866025403K2_000000000K1_732050807fftw_hc2real_15fftw_hc2real_15_desc;#Cl
fcr_16.o/ 1077312521 14522 10060 100644 3008 `
ELF>@@HcMcDLIO@H5BHE(B<%D\Y$LHDD(DYHD%D\$HDXFDY
T$,Dt$EXHD\B?H)DDYA\JEXD(L)D,HYDt$F4DYd$Ot$(\XDd$F$((A\AXDXIc\ILA(L$IAXH<4E\FDXH\HA((A\A(EXE(E\EXD(EXD\(AXYAXA\AXE\D(E(D\D$X(DXA\D<2H4I
A\Y%IA\IAXYD(YDd$DXd$D\X(AXFI)A\B,ID\$I)D\\$E((H(\X\D\$XT$B$,Y(B4D(D(AYEY(EYX$DYD(Yl$\d$AYEYD\EX(E\(E\DXL$EXA\D2@RP0M\eh
a
"/
<L0fcr_16.cK765366864K1_847759065K1_414213562K2_000000000fftw_hc2real_16fftw_hc2real_16_desc7Qg8D
fcr_32.o/ 1077312522 14522 10060 100644 5352 `
ELF>@@AWMcHcLIDAVIʸ4LA4A,AUDM=AT,O$@M
UIHIIMSIHHFDL$L\$MMIIB$B,MIF4LL$(H)(M)F$.L,AXD\F\XLJEY(YXA(Dl$F,\$A(DYAXYE\FDT$D(L$A(A(EXA\D$/K,D{??@fftw_hc2real_32x4
BUZ V(V0R8GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @
p0+`
0 &01
6
>2
R
PM\/e
"8CN[
h
x0fcr_32.cK765366864K1_847759065K555570233K831469612K195090322K980785280K1_414213562K2_000000000fftw_hc2real_32fftw_hc2real_32_desc6AX;"5>W} fcr_64.o/ 1077312522 14522 10060 100644 11880 `
ELF>`@@AWHcMcILItAVIMcIAUIMIATIIULHSH`D,.DL\$XF<I5Hl$PE(BY4'A(K,@FL$XEXHIA\HMF<7Lt$`A(IA(A4E(D5A(FY4.D(LAt4EXDYXE\D\F'E\MĻL(A(D(A(MALA\EXY
AXA\L,EXDY=$\A\(Y$XAXD\XML4D(D$TAX$PXD\E\$@B$$LID$HD(D$DLHEXA\DT$LD$LB4Lt$0MB&MF$DAl(MIE(BATIA(IX\D4\ƻ,DXB4?\$@AlBL$DO4MDXD$HMMA\(D$LAXF&A\IF4EXILA\¸TLD(A(JE(BFLD\$,l$,DX\A(EXD\l$L$A\D\I)EXD%X(E(E(DY5AXD\B<t$DT$D$D5D\DXAYAYD(EY$AXE\$(D$D%AXD\AYDYDYYT$$$EYDYDYY\$E\A\DXAXD$($D$X$\L$D$F,L$B4HD$XF$F4BHظlA\EXDt$DX\EXD$XD$A\D(MiA(IiE\AXDL$X\T$MiE\D$E(D\DX(D$DL$D\L$D$E(DXD\D$Xt$DL$D\T$DXL$T$AYDYAXD\A(XT$T$A\$D$D%D
DYYl$(DYYL$A\DL$(DXL$$DYY5T$DT$xE(DX((A\XAXDD$ E\D%A\AYDYT$$YT$pY5DY$<DL$tD$DX$DY\Y\$ $\XX$DY
YAXEXL$lD%\$ E(D\$,t$hDY(DYAXD\A\(\(XA\BAXLT$\$<$\$$\\$OI"DX$,:Y5LMHI(,*K,\$Y$D(ID(IY$A\L$AXYY=D\DXDDY$$T\$\Y$E(D$Y$4A(D\DX$4\DX$F*Y$AYFDL$B$DY$$MNDT$DY$$$MIALM)AXML$D(IAYF:A\O<D$TD\DX$XA(D\X(X=Y$(\(\XY$Y
AXD(\XD(D\DY
XB4A(B,A($D$DX\$\DY\$Y=A\$X$EXD$B$D\$\D
DY
LD(IA,E\AXDX$\$DB2M,2D,Y=D$D(DX$L\IiIiXE(E\EXD(D\$tA(A(A\(\XT$pY%A\D(X\DX(D\(DYB"XFY%\E(MiA\EX\X
LD,B42,2LLt$Y=$X$D$D$pDX$IDXD$tL)D$DX$$\$IiٜA(HXD\DX$@AXX$\Dd$F"Y5D
D$@D(D\$MiLEX(DY
HE(MiXE\EXE(YDXEYD\DYDl$D(A(A(D\l$D\\$A\YEXAYD(AXE\FYT$\DXA((\2LF"AXHME(M)\MDXD(IB4*F$$X%DX$(DT$Ll$DYT$$AYX$H\$D$XM)DX$$\$8Y=HDL$\$A(AYDYDY\$AXY\D$D\$DXA\DL$D\DY(E(XFE(%D\$(\X$8l$X$AXIiD(EYDYEX:D\HY4
DX(YA(HIiD$D\F,2MA\AXLtA\(EX\<2XDd$DY$Y$FDl$D5:DY$4
DY$$P\$D$PDX$d$A\DL$Y$\$D$Y$ EXDY$D(Y$0DDDXDY$ \DY$0E(Ii٘E\A((A(MiAXD$DXD\EYDY$IiD\(EXA(E(A\E\YDYEXEXE(A(\DXA\AX<AXF$E\B2MHL$YD$DX$B4DY5D$H$D\$$LDY\$L$ATDY
X$D$D\$\IiMiٔB$XE\EXD(MiBEX$LD2X$D,4Dl$xD\l$hA(MiIi(A\A(AXD(E\(DL$DXL$lA\D(Y%E(EXA(D\XY5\XE(EXDY=E\D\XDLB,A\BAdEXMLHHB2DY
F4*Dd$D$xD\d$l$XD$hD$X$$DX$T$\$IiE(E\D(EXD$HD\$E\F"DXD$D\$FMAYD$HAYDX$DY5A(MA(\Y\DXA(DYDd$AXD(XEYD\t$D\A((AY\E(XA\BEXA($%(IiYE\EXAX\F,D*(\X,2
Y$DYDXA\AXH`[]A\A]A^A_@9?1T?G>{?C?^?m~?6=Z>a?E?g"?1>t??@fftw_hc2real_64x<BTL M(H0H8GGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @P%+0 & .01060@>2pRXMP.\e!
h$
+6ANYd o$z(,048<
0fcr_64.cK555570233K831469612K195090322K980785280K765366864K1_847759065K995184726K098017140K471396736K881921264K773010453K634393284K290284677K956940335K1_414213562K2_000000000fftw_hc2real_64fftw_hc2real_64_descd888B8c447$@0H,P(n ,(+h Y4b8n844Lw +
o
c
,
,(, O(88 8p8449J8m8448`8884a44P4V454R%N8844,8P8(8F8`4444~ fcr_128.o/ 1077312523 14522 10060 100644 25072 `
ELF>G@@AWMcHcLE(M$lDA(4$tAXD$pLiE\IFE\MD($HA(Miش$LE\EX$X$PE\A(D,/BD(HiID\(Mi\EXD\D$TAXD((LظlA(EXAXD\D\\D$DAX$<D$@XD$8E\$4B$0D/B$HiF<>M(D(EXLA\FMiؔD$ D$ D4/F>A(BIAX$ A\A(ID\L\($H)X$AXX$DIEXDD$D\$,A(DY$PID\D$($\D$X$$TAXE\D$D\$DDXAXD\$TYA(D$xD=DX\DYD$D5$D\D$A(Y$HY5Y$HA(D\$YAXE\AYXA(Y$PD5D$p$tDD$(DY$LDYDY$X($AY\DY
X(DXD\Y$l%$hY$LE(E\AXD
EXD5A\DD$dA(D=D$DY$hAYD$`A(EY(D$Y\XE(EYDXA\$\$XA(DX\$TD$PDY%DY$h$@X$tD$xD\$<$`\$,YD=D
$pE\X$8$AXEYDD$,$pDX$`A(\$8E(D$DYY
DXEY\($tD$D\$@X$8D$H\D$xE\$LDX$<DX$@$<DYD$4D$0AYA\$,D5=Y$D%DY$05D$Y$dAYY$l$D$Y$0DY$dE(DY$l$XD$(=Y$4D\$XDDY$4D$(D($\$DXA\AXEYDXDYA\A((DYYA\EXX\E\$$DXD$ $$D$D$L$L$F?D\$\L$%$(DIX$X$B<>MIMAYF>IL$DY$FF4A(MII$XYDY$A\B4F?D$ME(M)D(L$$L$IA(F,>EXIA\EXLi\D$EXE(A(B?$\AXD(MiE\E\$F,'EXMIA(A(D$X\DXD\$$F>B4&D$LiMA(I$XF4?A\AXMiXE(D\(B$'I$IA(F>D$F&D\AXA(E\XAXD$A\\XD(E\D
$E\A($\$(Y$AXD\5($(A\DXA(\YAXDDY$EYDX$$$AY$5AXD$D(D$$$DYX\DYA\A\$$$\$DY=D%DYDY$
Y$Y$%Y$L$D$AXY$L$D$DY$I)MDXM)IEY$DY$DXBD(D$=Y$DXD$EXA\FD$D$DX$A\D$D$$AXE(E\$EXFE(D$A(D\DXD$B$H$,F4DLMXA(Xd$D\L$L$$AXB'l$A\LB,A\A(MLiHID(dLt$DXAXE\Mi\D$\F<7B$D$B4>D(\$IiDt$EXFDX(D$Dl$D\EX((ոhIiɠA\AXDt$DT$D\DXT$XE(t$Ii`DX\A\D$4D=D$E\D(EYXDYDXDl$
D(YL$\$D\\$E\D$D\DY$AX(D\l$D\\XA(D$(AX$0E\$,$$D5DY$$D$ Y\$
YL$Y$YAXEYDY$D5X$Y\$DY(XY$\A\D5A\$5EY$DY$(YXYl$\$YT$0X%$$$YAX(D
AYDYL$0AX\X\D($$E\D\XD$$D$Y$
Dd$8DT$@D\$$d$AYD\T$Xd${?m~?6=Z>a?M??:}?@>E?g"?1>t?> q?kg?>?0H=J+?=?=?[?x>Sx?C?^??@fftw_hc2real_128x<EBRU F(H0H8NGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rela.eh_frame.comment @EP+F0 &a010F60F>2FRFXMa\ G?Ge(K
) 0O!,7BMXc n$y(,048<@DHLPTX\`d)h4l?pJtWxd
qE0fcr_128.cK555570233K831469612K195090322K980785280K995184726K098017140K471396736K881921264K803207531K595699304K989176509K146730474K773010453K634393284K290284677K956940335K336889853K941544065K903989293K427555093K998795456K049067674K671558954K740951125K514102744K857728610K242980179K970031253K765366864K1_847759065K1_414213562K2_000000000fftw_hc2real_128fftw_hc2real_128_descxxxxt:ttmxxtlGp2`Rdh \; `C hj L P X T X%
LN
D\
@j
<
HH<j0s8,48 ,($$Z
v
dl~xxLT&/AIcu8,Hf8,8q,},;8u* < H]!he!<!H!`!$"`;"hd" "$# S#8##7$8q$L$X$L$X$,_%%,%&xJ't'ln(p(l)lp)l)l+lx+l,l,l,l ul.l//:000l0l1lT3l3l4l4l4la7l(8l68lD8l88l939v99lk:;;;l+<l@<k<?l@l@lAlFAlAA6BlLBeBCCl4DlUDDD&) fhb_2.o/ 1077312523 14522 10060 100644 2208 `
ELF>@@LcBMcNNJ(M)\XB9MHcffDAE FE(A(DXE\D\AXDE~6H(AY(YAYYX\BLA1M)9z9tD%E(DY(D(EY!DW%F$:@fftw_hc2hc_backward_2xGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.str1.1.rodata.cst16.rela.eh_frame.comment @0
+`0 &@H
16>2M`0[
jsHh
Z $)0Dfhb_2.cK2_000000000twiddle_order.LC1fftw_hc2hc_backward_2_descfftw_hc2hc_backward_2( fhb_3.o/ 1077312523 14522 10060 100644 2672 `
ELF>@@SLcAKIB,D=H(HcD5\A(YIcAYL(L)A9X\XBB$H<:DID%LIMB,ADE(?($BAXA(0A\D(DYD(XAYE\D(D\?XVE(^AYAXAY(D\(DXD\A(\AYAYAXYY\XB4>vHD(AY(DYAYYD\XDL)B4LA9A9t['E(FL2`8[X
j/sh } ,9 GLb0fhb_3.cK500000000K866025403K2_000000000K1_732050807twiddle_order.LC0fftw_hc2hc_backward_3fftw_hc2hc_backward_3_desc4( fhb_4.o/ 1077312523 14522 10060 100644 2768 `
ELF>@@AVLcAALAUHD%H8IcATLAUA(DA(SKI/HcB4BYYL,L)(E9X\((\XX\B'B,H<HLIHLLIMؐD/ADtB,D<A(DAXE\D2E((D\DXB,(A(AXA\DpL2`P[
js@ g # 16L0fhb_4.cK1_414213562K2_000000000twiddle_order.LC0fftw_hc2hc_backward_4fftw_hc2hc_backward_4_descp
( fhb_5.o/ 1077312524 14522 10060 100644 4104 `
ELF>@@AW=DHAVDD(AAUD=AATUS7T$$DT$LcL$L$(l$B?qxs?y?@??y?qx?fftw_hc2hc_backward_5x4BZR Q(A0A8GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
(
+`0 &H
16@>L2`P[
jHgs
( *5BMZg t0 0fhb_5.cK250000000K559016994K951056516K587785252K2_000000000K500000000K1_118033988K1_175570504K1_902113032twiddle_order.LC0fftw_hc2hc_backward_5fftw_hc2hc_backward_5_desc!3(6QZ7Qds(0 fhb_6.o/ 1077312524 14522 10060 100644 3880 `
ELF>@@AWH5%AVAUATUS?T$L$LcL$D(BLFOIHOD$D(JF,JE\J,HAXD$E\HD$LAYD(HAXYEXDY
AXE\A\YX\B4A(EXA\(\XB,FMcN'L)B<JL2`(P[
jxs
} ,9 GL\b0fhb_6.cK500000000K866025403K2_000000000K1_732050807twiddle_order.LC0fftw_hc2hc_backward_6fftw_hc2hc_backward_6_desc
4r3y( fhb_7.o/ 1077312524 14522 10060 100644 6368 `
ELF>@@@AWID=DAVDAUE(D(AT%US(HT$D$d$LcL$D$l$t$D$\$؉L$DL$N$LHIOIHD$M)L$JD$KN$DlHl$LHf??&H?y?&>@?>?&^??&?fftw_hc2hc_backward_7x4B
B[S J(Q0A8GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @B
p
+
0 &H
1
6
X>0L2@`XP[
js *5@KXe p$}(,0@ B
0fhb_7.cK222520933K900968867K623489801K781831482K974927912K433883739K2_000000000K1_801937735K445041867K1_246979603K867767478K1_949855824K1_563662964twiddle_order.LC0fftw_hc2hc_backward_7fftw_hc2hc_backward_7_desc,(!$*(>F9(O $1F_t1:JYrDZn'D(( I ( (@ fhb_8.o/ 1077312524 14522 10060 100644 4368 `
ELF> @@AWLcDOIOAVDMAUIIE(ATA(N$ULIN,SB$HFY,ωL$DT$T$I>DMD$Ld$LDD$JLE(HAL)4McBAY<HHl$DXD\B4D(D(E(A(\DXd
DY$EXJ,E\D\(DY\$XA(E(\\XYt$DX(AYA\A(EXEXE\\XD7\F$FDXB,BBAHD$IcDLHVH8(Y(AYYAYX\BLA<
L)D;\$)D;\$t[]A\A]A^A_MHOID\$LB,DME(IHcl$F4A4DXD\MK4A(IM$XA(D\B4Ed
JD(L)E(EXA\E(D\E\AXE(Y\$E\A(DXEXDYl$A\Y$(D=XE\EXA(Dl$܀t$߀D\$B<\YA(DFEXAYDDYd$A(AYAYA(EYDd$t$EYT$DYY\DXBEX\B$EWEWDBL2`P[
j( G s
H !,9F TYo0fhb_8.cK765366864K1_847759065K707106781K1_414213562K2_000000000twiddle_order.LC0fftw_hc2hc_backward_8fftw_hc2hc_backward_8_desc
Un
( fhb_9.o/ 1077312524 14522 10060 100644 7808 `
ELF>@@AWHIMcAVAUIATUSHP5T$LD5Lc\$LL$H\$LD't$4E(Dt$DHMO4K,[MMJ4JLcFL$4EY,D(YHLDE\LBLL$8L)JAXE(E(OALd$(E\ML,EXF,EX(LLE(HEXDY=EE\DY
A\AYDXDYE\XE(A(EX?A\DA\DY(DX\Y\$DEXE\X\4%5H,DD$D
AYYEYDYDT$$\$ A(AYAYXDY%E\AYD(A\A(DYL$4AXX\Y\$4X(W5XE\D\AX\FDJ44BBNHH)ǹ;L$HmHD$8L$H\$MHLl$LLt$MHD$IIIkLHL$MHD$HLILd$(Ht$?AD%E1(Ht$(E(>Ht$D>DXHt$D\C1DYA(E,1Ht$A\EXD(DY
EXDY5XYl$A\\($(D(A<1Ht$A\AXD<>AXHt$E\(d$GDA\%Y=t$D$D\$DD$AXED=DL$E(E(DYD\DXDYE\DXAYDt$D\DL$A$?t=G4D(ADXE(\A4<Y%AYEXD\E(ADt$EXDt$D(A(D<$D$ DX\YAYDd$D(X\t$XD\DXDY\AYd$DY
EYDYd$ Y\YX$E\Dt$\l$$DYAXA(DL$ YAX\$EXDYT$Dd$Yd$E\$DYAXEXDd$ DYL$XL$D\%AYDY\$$\AHt$D\T$DYY$$DYAXD(DX\Y5D\AR(EYDX\$A\D(D\$(A\DXA(DX\DYAr,(YYYXD\ED(EREB(A(DYA(YYE\DYA\\EXAd=\$Ht$d$E1Ht$Ez0EZ4A(DYE(EYDY$AYEXD$A\E\DXL$DY=Ht$G1D\$EBAjAXDY
A(D(YYE\DL$EXD\d$DY
A(AXDY%AXE\DYDYA\D\$E(A\AX(E(4>DXHt$C,A\ER Ej$E(DYA(EYYEYDXE\E4D>J4Ar8AjMD\E(d$DY
K1>UP?UZ?p?D>\?1>1>U?$?}D?թ???׳]?@׳?fftw_hc2hc_backward_9x<
BOB I(A0A8DGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @
+ 0 & H
1P6` >L2`X[h
j`s0 3 *5@KVa l$w(,048<@DHL`
0fhb_9.cK663413948K556670399K296198132K150383733K813797681K852868531K939692620K342020143K984807753K173648177K300767466K1_705737063K642787609K766044443K1_326827896K1_113340798K500000000K866025403K2_000000000K1_732050807twiddle_order.LC0fftw_hc2hc_backward_9fftw_hc2hc_backward_9_desc&D3H/<C@[@<48,0 $B(Y<@@<<G<O@@<@W<_@c0{0<<@@@@<<@( <Y @k <
<@E<V<^@<@@\em0
<
?
< (` fhb_10.o/ 1077312525 14522 10060 100644 6552 `
ELF>@@AWLcIIMcAVIAUMMATUK,SH4L<JH D=T$EL5Dd$L$Ll$HD/LDABMcE(MFLE\HIEXKRE(MIE44E\D2EXB4L)E(HT$%LE\(EYEXd$L4F\XDY$LA(H\DX(X\A(Y=XYD\Y(DYAXAYDY5D\A($H,A\A(\EXDX(XE(\E\EXH$DL$F<5D$<$HDY%YAYHD$AYDY$AYEXXD\A\DAXE\(A(X\\DXBJH)F,;L$J<WIkL$Lt$ILd$IIH\$HHT$HD$LIIHD$LIIHD$LIMMHD$HLL\$L\$fffHD$?DF4D<0(HD$E(AX,A\HD$0DXHD$d$D\$D<0D\$HD$FDD$F?E($0A(HD$A(D\D(HD$E\XB'D$0\A(HD$E\D(DXDX/A(EXA(EXF47AXD$AXE\D0E\DYAX$A\A(D<3Dl$D(\E(D$DXB\AX(A(t$A\AXE43E\D(D\DX\A(YA\EXD(AXDX(A(XE\D(E\DXD\\\A(DL$HD$Y=\$AXAXD=E\DL$AXD5DYDYX
d$EYYL$D$d$Yt$DY5E\AYE\D=AY\DY(EYE(D\AXD
DYL$DX(\XAQDX5Yt$(A\E(E\EXD(DXAYAY\(AYA\AYDXX\B0EQqxs?y???qx?y?@? fftw_hc2hc_backward_10x<kBRI I(A0E8XXGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @k0
+0 &8H
16
d >p
L2
`
X[
j
sH( p
+6AN[h u@$ k0fhb_10.cK250000000K951056516K587785252K559016994K500000000K1_902113032K1_175570504K2_000000000K1_118033988twiddle_order.LC0fftw_hc2hc_backward_10fftw_hc2hc_backward_10_descIWlx R4Mgp5;Q'@i}
Sa1(@ fhb_16.o/ 1077312525 14522 10060 100644 9440 `
ELF>@@AWHIIMcAVIAUATUSHH$$xHc$
$8IHHLH$<H9IHLmID$<E<,D(L$@D$IA(IMH$HL,AXIH4E\IL$PD\F,7XD$<FY'L$0IEY$<A(AY$IDXYI)D$lN<D\DDY$8MLHY$tIE(EXE\$pL$ F4$L$A\E(L\L$IEXHN<E\H$E(L$IM,D\B9?1?5?>^l?C?^??@
fftw_hc2hc_backward_16x<BZI B(A0A8JGCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @!x
+@0 &$H
1p6 >L2`(X[$
jsX 0
"/<GR]h u$(@< 0fhb_16.cK1_961570560K390180644K1_111140466K1_662939224K707106781K382683432K923879532K765366864K1_847759065K1_414213562K2_000000000twiddle_order.LC0fftw_hc2hc_backward_16fftw_hc2hc_backward_16_desc7 U$' . L 7
E
t}7
3.T(@ fhb_32.o/ 1077312526 14522 10060 100644 22600 `
ELF>B@@AWA4McAVAUATUSHHHD%$$Lc$HD=D$h$hLMMHIIO$vMI?LB<L$D$lMIDlB'H$(L$EL$\E(D$lL$EXIME\IL$x(HMMH$pXL$`MAXEYؽ,A\MMMDYDYD$YDLHLD$D$A($L$XL$PF?L$HLIHE4OAXE\B$EJ4LAMD(E(I(H$@E(LA4L$0EXD
E\(F4/M\IHXE(L$8EXMID\(%MDXD\E\EXAYAXDYAYD\DYEYAXDYID\$$lD$BY<AYA\$DY5D?EXD$H$(D$lDY$\$JLHD$EX$MID$E(H$ $l7L$HF,L)ADD\H,L$DDXH$A4H$MIE(L$MML$A(IDN,A\E(LA,EXH$L$E(勄$$ML$A(L)D(D$D(H$ML$EXHHA\L$H$D(HILD\E((DXB4DXD\A(XA\EL$E\DX(B,MDXA(LAXAYD\AXA\AX$D\BE\$D$DY$l$$$D$H$L$A$L$??1?Zq???g?6H>m?>^l?5?C?^?9?1T?G>{??@
fftw_hc2hc_backward_32x<*@BKB B(A0A8Q
GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.rela.data.bss.rodata.rodata.cst16.rodata.str1.1.rela.eh_frame.comment @*@XK
+@0 &WH
1@6@ >AL2A`AX[0X
j B?BsxFx# Ic
$/<IT_l y$(,048<@DHLPTX` +0*@G0fhb_32.cK1_662939224K1_111140466K390180644K1_961570560K1_913880671K580569354K942793473K1_763842528K1_546020906K1_268786568K196034280K1_990369453K382683432K923879532K707106781K765366864K1_847759065K555570233K831469612K195090322K980785280K1_414213562K2_000000000twiddle_order.LC0fftw_hc2hc_backward_32fftw_hc2hc_backward_32_desc)POTLKHxD@H@L6D0@WD@DLH%H6L<84j4444i4440,6,f,y00+,4,=0F0j0w,0,0,,4V44*4 4!4!4!4"L"H"L#H,#HD#L#H#L$,7%4E%,%0%0%4%,=&,x&0&0'4'0(0+(,F(0b(,z(,(0(4D),D*D`*@*D*@+D1+@j+@+DHkHHHLL.Ln.L/D30@P0@0D0@0D0DB1@40}5,505050(646474,7480F80b8080w9!:$:;(; ;F<q<<=>4P>4^>4>>>4&?Z?#(` rconfig.o/ 1077312526 14522 10060 100644 5672 `
ELF>@@ GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.rela.data.bss.comment@&@ !,(1(G:H s,@Th0DXl(=Rg&@[u/Id~ <Wrconfig.crfftw_configfftw_real2hc_1_descfftw_hc2real_1_descfftw_real2hc_2_descfftw_hc2real_2_descfftw_real2hc_3_descfftw_hc2real_3_descfftw_real2hc_4_descfftw_hc2real_4_descfftw_real2hc_5_descfftw_hc2real_5_descfftw_real2hc_6_descfftw_hc2real_6_descfftw_real2hc_7_descfftw_hc2real_7_descfftw_real2hc_8_descfftw_hc2real_8_descfftw_real2hc_9_descfftw_hc2real_9_descfftw_real2hc_10_descfftw_hc2real_10_descfftw_real2hc_11_descfftw_hc2real_11_descfftw_real2hc_12_descfftw_hc2real_12_descfftw_real2hc_13_descfftw_hc2real_13_descfftw_real2hc_14_descfftw_hc2real_14_descfftw_real2hc_15_descfftw_hc2real_15_descfftw_real2hc_16_descfftw_hc2real_16_descfftw_real2hc_32_descfftw_hc2real_32_descfftw_real2hc_64_descfftw_hc2real_64_descfftw_real2hc_128_descfftw_hc2real_128_descfftw_hc2hc_forward_2_descfftw_hc2hc_backward_2_descfftw_hc2hc_forward_3_descfftw_hc2hc_backward_3_descfftw_hc2hc_forward_4_descfftw_hc2hc_backward_4_descfftw_hc2hc_forward_5_descfftw_hc2hc_backward_5_descfftw_hc2hc_forward_6_descfftw_hc2hc_backward_6_descfftw_hc2hc_forward_7_descfftw_hc2hc_backward_7_descfftw_hc2hc_forward_8_descfftw_hc2hc_backward_8_descfftw_hc2hc_forward_9_descfftw_hc2hc_backward_9_descfftw_hc2hc_forward_10_descfftw_hc2hc_backward_10_descfftw_hc2hc_forward_16_descfftw_hc2hc_backward_16_descfftw_hc2hc_forward_32_descfftw_hc2hc_backward_32_desc
(0
8@HPX`hpx !"#$%&'()* +(,08.@/H0P1X2`3h4p5x6789:;<=>?@ABrplanner.o/ 1077312526 14522 10060 100644 10408 `
ELF>X@@ Hl$Ld$L$H\$Ll$Lt$HhAHL$(ELL$ 1Ʌ~cAAÃ!بuGH$0Lt$0DLHHtDHLH{ HH\$8Hl$@HLd$HLl$PLt$XL$`HhËL$pHT$ ALL$(LD<$L$HT$DDHHtSHLDC0DL$pDDD$E{$s4$DH$0HEKDL$pH\$ ADDLD<$DL$H\$LL$(HHnH\$Ld$Lt$Hl$Ll$AH8AthLcJ<H1Ht0NLDAHD$HILH\$Hl$Ld$ Ll$(Lt$0H8E1A1$H\$Hl$Ld$ Ll$(Lt$0H8ffffffffffffffffffffffHH=HffffffffffH\$Hl$Ll$Lt$L$Ld$HAEHL$PLL$8D$D$AH\$THL$H$@DHL$LDD$H\$H$1҅L$LQHHuHHH9ku9Kus9t$PuD9ku׃HDDKDCDHDD$$HHH=xHoH{ 3HVffft.1H\$XHl$`HLd$hLl$pLt$xL$HĈHAHtDL$,
II$Ht9ku$L9{uDCD9D$PuڋK~D҉uƃ$TD$D$L$H$@D$LL$8AED\$LT$AȋL$,
HHD$0qHH HEDDKDCDDd$THDD$D$$HHH=tHtH{ 3HH$0HHD3ffffAWAVAAUATAUSHhHH$XL$TDD$PLL$HHD$@HHufffffII$H9kuSJwD9suكYHDDKDCH\$PL$TD$\$HHH=tHtH{ 3HCD$H$Hߋ$Ht$HC(Ht$@HHD$@II$H*HHAHD$TAfII$H9ku{uKD҉uՃ~H$@t
A9ffftD$H$D$LL$HDD$H$DD$PH$X$qHIuHH DD$THډDt$PDKDDCL$TH$t$HHH=tHtH{ 3HLCD$H$Hߋ$Ht$H3C(Ht$@HHD$@H{ *D$ *K4fT$ YYS(;HDH{ *+l$ *c4f\$ YY[(yfffffD$TrHAH\D$TAII$H=9ku{uKD҉uՃ~H$@tA9fftD$D$AL$H$XDD$D\$LL$HLT$HIwHH DD$THډDL$PDKDCHD$L$L$THHH=tHtH{ 3HLCD$H$Hߋ$Ht$HCC(Ht$@HHD$@fffffAHD$8HDT$8D$4EAHT$8~`T$TT$0DD;\$4AAt4H\$4HukHHHt_9huxu9XuAHD$@Hh[]A\A]A^A_H{ D*DD$ *{4ft$ YYs(fftDD$LL$HDD$PL$0H$H$XD<$HT$Ƌ$D$DL$THL$8L@ DI\$PL$TE1AHD$\$HHH=tHtH{ 3HLCt@D$H$Hߋ$Ht$HPC(Ht$@HHD$@H{ D*D\$ D*S4fDL$ DYEYDK(AWAVIAUIATEUSHD4HL$HD$<AT$,f
D$,L$@~T$,1HcA4uD$8HD$`HT$hHD$pHT$xHT$hH$HD$`T${Gz? _B@x$bp$DYG@l$e<BBE B(G0C8D<BBE E(D0C8G,\BOTG`GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.rela.text.data.bss.rodata.cst8.rela.eh_frame.comment @
&4,818 CX>'
MVX `,B5 KPUZ_o'`:Upgx&A]irplanner.crplanner_wisdomrplanner_normalrplannerrfftw_measure_runtime.LC5.LC2.LC6.LC4rfftw_plan_hookrfftw_create_plan_specificfftw_make_empty_tablefftw_lookupfftw_use_planfftw_destroy_tablefftw_complete_twiddlefftw_insertfftw_wisdom_addrfftw_create_planfftw_mallocfftw_freerfftw_destroy_planfftw_destroy_plan_internalrfftw_fprint_planfftw_fprint_planrfftw_print_planstdoutfftw_wisdom_lookuprfftw_configfftw_make_node_hc2realfftw_make_planfftw_make_node_hc2hcfftw_make_node_real2hcfftw_pick_betterfftw_estimate_nodefftw_hc2hc_forward_genericfftw_hc2hc_backward_genericfftw_factorfftw_make_node_rgenericfftw_gettimeofday_get_timerfftwfftw_gettimeofday_time_diffas3=5!"<#A
#$%&#,
#&%+4>Q'm
##$%!4=}(#
#]&%()@'X)#
#M &u % (
*
+F
,a
#j
#
)Cl%w~()[../.0
0j
0w
0
0
#7.l000)06N
q
uaq Hp`p` `rexec.o/ 1077312526 14522 10060 100644 6784 `
ELF>X@@ H\$Hl$Ll$Lt$L$Ld$HIH$`HEE wK" H$hH$pL$xL$L$L$HĘÃuDaA$LAL$HyHOH$CoAEDዔ$H$L$LS $EEAAD$$ED$\1DH$`HcL$\HcD$ELT$$DH$I4LD$LT$Dd$\uDaA$\A$\HQL$\AHr$SLS DAA$oED$81DLcL$8L$`Hc$\ELLT$$DIK4D$D$LT$DD$8uLQ DƋ$\AAAɉ$X$TE~qD$,D$(DfffLcD$,LcL$(LL$`$\LT$$K4KD$XE$TDl$,$(LT$uHk$\E$\H$`HuASLS D$DAAEΉ$D$8E~lD$PD$LDHct$LLc\$PEH$`D$LT$$$HLK4$Dl$PT$LLT$u$H$EH$`AD$IBEH$HLc$TDD$D$D剔$DL$8Hc$HcL$H$8L$`D$DHII4EI<$X$HD$TDl$Dd$uZIBEH$Z$\D$D$0$1DAD$HH$HcL$0L$HcL$`DIKI4D$I@@AWAVAUATAUHSAHA$DƉL$}t$:ωSwA9}0fD$McLcF\L$D)AHFA9DTFTD;d$t$Et$AD$Dt$D$AL$AD<1Dt$AAD$D$IctDDDLD\D)AHTDTLIcƉ4EIcTDELcD$HcT$LDl$Dl$D;d$FBDDTD$u!D$Lc$D$FdHD$D[]A\A]A^A_AWAVAUATAUHSHˉΉ$T$Ut$ɃyA9}1t$LcD$McF\t$D)AFHA9FDDD;d$Et$Dl$AD$Dt$D$E$F@@
AWAAVAAUAATIUSH8HDD$pT$,LD$0DHD$ H1HbEU1D9}4LE McG\HcDBpAAD9A4EIcH}EDEAEAADDDHHE($AT$,DLU(HIDADH$0@ UH$ !بAt
AL\$0EAuHM H}(AD$HD$D$L$ELHtmHuDE0DE4tEy.HH8[]A\A]A^A_H}(EAuADLHcHHHE8uH1H8[]A\A]A^A_HM H}(EHD$ AuAD$HD$D$H$0DHE(ffffffAWEAVAUIHcATUSHXH$8HL$HT$TH\$8IMDL$DIU E~1DfAN$AMV(EL$LD$8HcL$$IcHcMD$IIDD$4$t$@DL$Dd$l$0u7Iv(HcD9H\D;E11DIv(AN$DL$AL\$8HcDLcIOD$LcJ$H$DD$4DT$$DHt$t$@Dd$0uffffffffffAWAVIAUATUSHx_$HT$pL$l$DD$hLL$`D$LD$XHG8T$\HD$Pt
A$h$lD$X$\@9$h tDD$hADD$hADD$XDT$hL\$pAD9T$lL\$`D!ȨMfLcAN4CD9sAH$PD!*uD$XA9D$\D!9D$4D$0l$,IV LcT$01Hc$4L\$pLD$`I^D*AVOI4jLL$@Ht$839II~(LcENdEA$GE11fffDT$\$lLL$8HL$PHt$@DDAH$EL$lIcMHcDL$\HLuI^(L$\DLL$PDD$\HT$8H;$D$Al$hDl$Xl$0Dl$4jDADAEQADA92L$\H?DLL$PDD$\D$HT$8$ADl$ht$XDl$0t$4L$,xA.tjDT$lMN(HcHL$PD$lEILL$8HL$D<$DGDT$HT$@I~([HcHD$LHD$PMF(LcL\$PT$\\$\LL$8L$lKDD$lADL\$T$$E&EAÃD!بtD$hD9$lMV(Ht$PL$\D$XLL$`DD$hHt$HT$p$D$L$lI:Dt$LEuHx[]A\A]A^A_H$PHx[]A\A]A^A_LD$`Ld$PD\$X\$\1DL$hHL$pLL$Ld$DD$lD\$\$HcHHHD$PtQD$LAN4fMn(LL$PT$X$\DD$hL$lLL$LL$`T$<$HT$pI}&fffffAWAAVIAUATUSH_$H$DD$$LL$pD$\D$8HG8T$lHD$`t
A$D$lD$8@D9$ t
$$8L$AD;$LL$pD!kcMVLcAN4CD9#AH$`D!#Dd$8D9d$l!9YD$@D$<l$4fffHc$@LD$pIv LcT$@@AWAVAUAATIHcHUHSDH(T$$DL$ D\$$IE1D\$ DAIcE9IHHT$M<}{WE11(D9(D}DE1DffffIcHcA,7(YlYD)9MEXXuIcDT$$AC AA\D9A>AAA<$~7DDAIcLcAADCATLcDCGE9LcD$ D$KHcHc$LAY$AAYL)9Mƍ6X9XZZAIcDL$ EXA9XZAzLcD$D$OJML$I)I)׃$ pEWHT$19:EE11AHcLcDAIcEBABTD, A99}GAEEDEAAfffHcLcDAIcEЁ9BTABE1A9E(E1E1ҋT$1DA(A(A9}gfffHcE$A\HcDDLE(E()EY9DYLEY9DYEXE\AXAXAIcDT$ EA@@GCC: (GNU) 3.3.1 (SuSE Linux).symtab.strtab.shstrtab.text.data.bss.comment@!@'@,@_5 (rfftwf77.c