00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #if !defined (octave_oct_fftw_h)
00024 #define octave_oct_fftw_h 1
00025
00026 #include <cstddef>
00027
00028 #if defined (HAVE_FFTW3_H)
00029 #include <fftw3.h>
00030 #endif
00031
00032 #include "oct-cmplx.h"
00033 #include "dim-vector.h"
00034
00035 #if defined (HAVE_FFTW)
00036
00037 class
00038 OCTAVE_API
00039 octave_fftw_planner
00040 {
00041 protected:
00042
00043 octave_fftw_planner (void);
00044
00045 public:
00046
00047 ~octave_fftw_planner (void) { }
00048
00049 enum FftwMethod
00050 {
00051 UNKNOWN = -1,
00052 ESTIMATE,
00053 MEASURE,
00054 PATIENT,
00055 EXHAUSTIVE,
00056 HYBRID
00057 };
00058
00059 static bool instance_ok (void);
00060
00061 static fftw_plan
00062 create_plan (int dir, const int rank, const dim_vector dims,
00063 octave_idx_type howmany, octave_idx_type stride,
00064 octave_idx_type dist, const Complex *in,
00065 Complex *out)
00066 {
00067 static fftw_plan dummy;
00068
00069 return instance_ok ()
00070 ? instance->do_create_plan (dir, rank, dims, howmany, stride,
00071 dist, in, out)
00072 : dummy;
00073 }
00074
00075 static fftw_plan
00076 create_plan (const int rank, const dim_vector dims,
00077 octave_idx_type howmany, octave_idx_type stride,
00078 octave_idx_type dist, const double *in, Complex *out)
00079 {
00080 static fftw_plan dummy;
00081
00082 return instance_ok ()
00083 ? instance->do_create_plan (rank, dims, howmany, stride, dist, in, out)
00084 : dummy;
00085 }
00086
00087 static FftwMethod method (void)
00088 {
00089 static FftwMethod dummy;
00090
00091 return instance_ok () ? instance->do_method () : dummy;
00092 }
00093
00094 static FftwMethod method (FftwMethod _meth)
00095 {
00096 static FftwMethod dummy;
00097
00098 return instance_ok () ? instance->do_method (_meth) : dummy;
00099 }
00100
00101 private:
00102
00103
00104
00105 octave_fftw_planner (const octave_fftw_planner&);
00106
00107 octave_fftw_planner& operator = (const octave_fftw_planner&);
00108
00109 static octave_fftw_planner *instance;
00110
00111 fftw_plan
00112 do_create_plan (int dir, const int rank, const dim_vector dims,
00113 octave_idx_type howmany, octave_idx_type stride,
00114 octave_idx_type dist, const Complex *in,
00115 Complex *out);
00116
00117 fftw_plan
00118 do_create_plan (const int rank, const dim_vector dims,
00119 octave_idx_type howmany, octave_idx_type stride,
00120 octave_idx_type dist, const double *in, Complex *out);
00121
00122 FftwMethod do_method (void);
00123
00124 FftwMethod do_method (FftwMethod _meth);
00125
00126 FftwMethod meth;
00127
00128
00129
00130
00131 fftw_plan plan[2];
00132
00133
00134 octave_idx_type d[2];
00135
00136
00137 octave_idx_type s[2];
00138
00139
00140 int r[2];
00141
00142
00143 octave_idx_type h[2];
00144
00145
00146 dim_vector n[2];
00147
00148 bool simd_align[2];
00149 bool inplace[2];
00150
00151
00152 fftw_plan rplan;
00153
00154
00155 octave_idx_type rd;
00156
00157
00158 octave_idx_type rs;
00159
00160
00161 int rr;
00162
00163
00164 octave_idx_type rh;
00165
00166
00167 dim_vector rn;
00168
00169 bool rsimd_align;
00170 };
00171
00172 class
00173 OCTAVE_API
00174 octave_float_fftw_planner
00175 {
00176 protected:
00177
00178 octave_float_fftw_planner (void);
00179
00180 public:
00181
00182 ~octave_float_fftw_planner (void) { }
00183
00184 enum FftwMethod
00185 {
00186 UNKNOWN = -1,
00187 ESTIMATE,
00188 MEASURE,
00189 PATIENT,
00190 EXHAUSTIVE,
00191 HYBRID
00192 };
00193
00194 static bool instance_ok (void);
00195
00196 static fftwf_plan
00197 create_plan (int dir, const int rank, const dim_vector dims,
00198 octave_idx_type howmany, octave_idx_type stride,
00199 octave_idx_type dist, const FloatComplex *in,
00200 FloatComplex *out)
00201 {
00202 static fftwf_plan dummy;
00203
00204 return instance_ok ()
00205 ? instance->do_create_plan (dir, rank, dims, howmany, stride,
00206 dist, in, out)
00207 : dummy;
00208 }
00209
00210 static fftwf_plan
00211 create_plan (const int rank, const dim_vector dims,
00212 octave_idx_type howmany, octave_idx_type stride,
00213 octave_idx_type dist, const float *in, FloatComplex *out)
00214 {
00215 static fftwf_plan dummy;
00216
00217 return instance_ok ()
00218 ? instance->do_create_plan (rank, dims, howmany, stride, dist, in, out)
00219 : dummy;
00220 }
00221
00222 static FftwMethod method (void)
00223 {
00224 static FftwMethod dummy;
00225
00226 return instance_ok () ? instance->method () : dummy;
00227 }
00228
00229 static FftwMethod method (FftwMethod _meth)
00230 {
00231 static FftwMethod dummy;
00232
00233 return instance_ok () ? instance->method (_meth) : dummy;
00234 }
00235
00236 private:
00237
00238
00239
00240 octave_float_fftw_planner (const octave_float_fftw_planner&);
00241
00242 octave_float_fftw_planner& operator = (const octave_float_fftw_planner&);
00243
00244 static octave_float_fftw_planner *instance;
00245
00246 fftwf_plan
00247 do_create_plan (int dir, const int rank, const dim_vector dims,
00248 octave_idx_type howmany, octave_idx_type stride,
00249 octave_idx_type dist, const FloatComplex *in,
00250 FloatComplex *out);
00251
00252 fftwf_plan
00253 do_create_plan (const int rank, const dim_vector dims,
00254 octave_idx_type howmany, octave_idx_type stride,
00255 octave_idx_type dist, const float *in, FloatComplex *out);
00256
00257 FftwMethod do_method (void);
00258
00259 FftwMethod do_method (FftwMethod _meth);
00260
00261 FftwMethod meth;
00262
00263
00264
00265
00266 fftwf_plan plan[2];
00267
00268
00269 octave_idx_type d[2];
00270
00271
00272 octave_idx_type s[2];
00273
00274
00275 int r[2];
00276
00277
00278 octave_idx_type h[2];
00279
00280
00281 dim_vector n[2];
00282
00283 bool simd_align[2];
00284 bool inplace[2];
00285
00286
00287 fftwf_plan rplan;
00288
00289
00290 octave_idx_type rd;
00291
00292
00293 octave_idx_type rs;
00294
00295
00296 int rr;
00297
00298
00299 octave_idx_type rh;
00300
00301
00302 dim_vector rn;
00303
00304 bool rsimd_align;
00305 };
00306
00307 class
00308 OCTAVE_API
00309 octave_fftw
00310 {
00311 public:
00312
00313 static int fft (const double *in, Complex *out, size_t npts,
00314 size_t nsamples = 1, octave_idx_type stride = 1, octave_idx_type dist = -1);
00315 static int fft (const Complex *in, Complex *out, size_t npts,
00316 size_t nsamples = 1, octave_idx_type stride = 1, octave_idx_type dist = -1);
00317 static int ifft (const Complex *in, Complex *out, size_t npts,
00318 size_t nsamples = 1, octave_idx_type stride = 1, octave_idx_type dist = -1);
00319
00320 static int fftNd (const double*, Complex*, const int, const dim_vector &);
00321 static int fftNd (const Complex*, Complex*, const int,
00322 const dim_vector &);
00323 static int ifftNd (const Complex*, Complex*, const int,
00324 const dim_vector &);
00325
00326 static int fft (const float *in, FloatComplex *out, size_t npts,
00327 size_t nsamples = 1, octave_idx_type stride = 1, octave_idx_type dist = -1);
00328 static int fft (const FloatComplex *in, FloatComplex *out, size_t npts,
00329 size_t nsamples = 1, octave_idx_type stride = 1, octave_idx_type dist = -1);
00330 static int ifft (const FloatComplex *in, FloatComplex *out, size_t npts,
00331 size_t nsamples = 1, octave_idx_type stride = 1, octave_idx_type dist = -1);
00332
00333 static int fftNd (const float*, FloatComplex*, const int, const dim_vector &);
00334 static int fftNd (const FloatComplex*, FloatComplex*, const int,
00335 const dim_vector &);
00336 static int ifftNd (const FloatComplex*, FloatComplex*, const int,
00337 const dim_vector &);
00338
00339 private:
00340 octave_fftw (void);
00341 octave_fftw (const octave_fftw&);
00342 octave_fftw& operator = (const octave_fftw&);
00343 };
00344
00345 #endif
00346
00347 #endif