fftw3 (JavaCPP Presets for FFTW 3.3.10-1.5.10 API)

java.lang.Object
- org.bytedeco.fftw.presets.fftw3
- - org.bytedeco.fftw.global.fftw3

All Implemented Interfaces:

InfoMapper
```
public class fftw3
extends fftw3
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`fftw3.fftw_iodim`
`static class`	`fftw3.fftw_iodim64`
`static class`	`fftw3.fftw_plan`
`static class`	`fftw3.fftw_read_char_func_do_not_use_me`
`static class`	`fftw3.fftw_write_char_func_do_not_use_me`
`static class`	`fftw3.fftwf_plan`
`static class`	`fftw3.Parallel_loop_Work_byte___byte___long_int_Pointer`
`static class`	`fftw3.Parallel_loop_Work_ByteBuffer_ByteBuffer_long_int_Pointer`
`static class`	`fftw3.Parallel_loop_Work_BytePointer_BytePointer_long_int_Pointer`
`static class`	`fftw3.Work_byte__`
`static class`	`fftw3.Work_ByteBuffer`
`static class`	`fftw3.Work_BytePointer`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`FFTW_ALLOW_LARGE_GENERIC`
`static int`	`FFTW_ALLOW_PRUNING`
`static int`	`FFTW_BACKWARD`
`static int`	`FFTW_BELIEVE_PCOST`
`static int`	`FFTW_CONSERVE_MEMORY`
`static int`	`FFTW_DESTROY_INPUT`
`static int`	`FFTW_DHT` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_ESTIMATE`
`static int`	`FFTW_ESTIMATE_PATIENT`
`static int`	`FFTW_EXHAUSTIVE`
`static int`	`FFTW_FORWARD`
`static int`	`FFTW_HC2R` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_MEASURE`
`static int`	`FFTW_NO_BUFFERING`
`static int`	`FFTW_NO_DFT_R2HC`
`static int`	`FFTW_NO_FIXED_RADIX_LARGE_N`
`static int`	`FFTW_NO_INDIRECT_OP`
`static int`	`FFTW_NO_NONTHREADED`
`static int`	`FFTW_NO_RANK_SPLITS`
`static int`	`FFTW_NO_SIMD`
`static int`	`FFTW_NO_SLOW`
`static double`	`FFTW_NO_TIMELIMIT`
`static int`	`FFTW_NO_VRANK_SPLITS`
`static int`	`FFTW_NO_VRECURSE`
`static int`	`FFTW_PATIENT`
`static int`	`FFTW_PRESERVE_INPUT`
`static int`	`FFTW_R2HC` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_REDFT00` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_REDFT01` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_REDFT10` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_REDFT11` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_RODFT00` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_RODFT01` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_RODFT10` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_RODFT11` enum fftw_r2r_kind_do_not_use_me
`static int`	`FFTW_UNALIGNED`
`static int`	`FFTW_WISDOM_ONLY`

Constructor Summary

Constructors
Constructor and Description

fftw3()

Constructors
Constructor and Description
`fftw3()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`fftw_alignment_of(double[] p)`
`static int`	`fftw_alignment_of(DoubleBuffer p)`
`static int`	`fftw_alignment_of(DoublePointer p)`
`static DoublePointer`	`fftw_alloc_complex(long n)`
`static DoublePointer`	`fftw_alloc_real(long n)`
`static BytePointer`	`fftw_cc()`
`static byte`	`fftw_cc(int i)`
`static void`	`fftw_cleanup_threads()`
`static void`	`fftw_cleanup()`
`static BytePointer`	`fftw_codelet_optim()`
`static byte`	`fftw_codelet_optim(int i)`
`static double`	`fftw_cost(fftw3.fftw_plan p)`
`static void`	`fftw_destroy_plan(fftw3.fftw_plan p)`
`static double`	`fftw_estimate_cost(fftw3.fftw_plan p)`
`static void`	`fftw_execute_dft_c2r(fftw3.fftw_plan p, double[] in, double[] out)`
`static void`	`fftw_execute_dft_c2r(fftw3.fftw_plan p, DoubleBuffer in, DoubleBuffer out)`
`static void`	`fftw_execute_dft_c2r(fftw3.fftw_plan p, DoublePointer in, DoublePointer out)`
`static void`	`fftw_execute_dft_r2c(fftw3.fftw_plan p, double[] in, double[] out)`
`static void`	`fftw_execute_dft_r2c(fftw3.fftw_plan p, DoubleBuffer in, DoubleBuffer out)`
`static void`	`fftw_execute_dft_r2c(fftw3.fftw_plan p, DoublePointer in, DoublePointer out)`
`static void`	`fftw_execute_dft(fftw3.fftw_plan p, double[] in, double[] out)`
`static void`	`fftw_execute_dft(fftw3.fftw_plan p, DoubleBuffer in, DoubleBuffer out)`
`static void`	`fftw_execute_dft(fftw3.fftw_plan p, DoublePointer in, DoublePointer out)`
`static void`	`fftw_execute_r2r(fftw3.fftw_plan p, double[] in, double[] out)`
`static void`	`fftw_execute_r2r(fftw3.fftw_plan p, DoubleBuffer in, DoubleBuffer out)`
`static void`	`fftw_execute_r2r(fftw3.fftw_plan p, DoublePointer in, DoublePointer out)`
`static void`	`fftw_execute_split_dft_c2r(fftw3.fftw_plan p, double[] ri, double[] ii, double[] out)`
`static void`	`fftw_execute_split_dft_c2r(fftw3.fftw_plan p, DoubleBuffer ri, DoubleBuffer ii, DoubleBuffer out)`
`static void`	`fftw_execute_split_dft_c2r(fftw3.fftw_plan p, DoublePointer ri, DoublePointer ii, DoublePointer out)`
`static void`	`fftw_execute_split_dft_r2c(fftw3.fftw_plan p, double[] in, double[] ro, double[] io)`
`static void`	`fftw_execute_split_dft_r2c(fftw3.fftw_plan p, DoubleBuffer in, DoubleBuffer ro, DoubleBuffer io)`
`static void`	`fftw_execute_split_dft_r2c(fftw3.fftw_plan p, DoublePointer in, DoublePointer ro, DoublePointer io)`
`static void`	`fftw_execute_split_dft(fftw3.fftw_plan p, double[] ri, double[] ii, double[] ro, double[] io)`
`static void`	`fftw_execute_split_dft(fftw3.fftw_plan p, DoubleBuffer ri, DoubleBuffer ii, DoubleBuffer ro, DoubleBuffer io)`
`static void`	`fftw_execute_split_dft(fftw3.fftw_plan p, DoublePointer ri, DoublePointer ii, DoublePointer ro, DoublePointer io)`
`static void`	`fftw_execute(fftw3.fftw_plan p)`
`static void`	`fftw_export_wisdom_to_file(Pointer output_file)`
`static int`	`fftw_export_wisdom_to_filename(BytePointer filename)`
`static int`	`fftw_export_wisdom_to_filename(String filename)`
`static BytePointer`	`fftw_export_wisdom_to_string()`
`static void`	`fftw_export_wisdom(fftw3.fftw_write_char_func_do_not_use_me write_char, Pointer data)`
`static void`	`fftw_flops(fftw3.fftw_plan p, double[] add, double[] mul, double[] fmas)`
`static void`	`fftw_flops(fftw3.fftw_plan p, DoubleBuffer add, DoubleBuffer mul, DoubleBuffer fmas)`
`static void`	`fftw_flops(fftw3.fftw_plan p, DoublePointer add, DoublePointer mul, DoublePointer fmas)`
`static void`	`fftw_forget_wisdom()`
`static void`	`fftw_fprint_plan(fftw3.fftw_plan p, Pointer output_file)`
`static void`	`fftw_free(Pointer p)`
`static int`	`fftw_import_system_wisdom()`
`static int`	`fftw_import_wisdom_from_file(Pointer input_file)`
`static int`	`fftw_import_wisdom_from_filename(BytePointer filename)`
`static int`	`fftw_import_wisdom_from_filename(String filename)`
`static int`	`fftw_import_wisdom_from_string(BytePointer input_string)`
`static int`	`fftw_import_wisdom_from_string(String input_string)`
`static int`	`fftw_import_wisdom(fftw3.fftw_read_char_func_do_not_use_me read_char, Pointer data)`
`static int`	`fftw_init_threads()`
`static void`	`fftw_make_planner_thread_safe()`
`static Pointer`	`fftw_malloc(long n)`
`static fftw3.fftw_plan`	`fftw_plan_dft_1d(int n, double[] in, double[] out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_1d(int n, DoubleBuffer in, DoubleBuffer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_1d(int n, DoublePointer in, DoublePointer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_2d(int n0, int n1, double[] in, double[] out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_2d(int n0, int n1, DoubleBuffer in, DoubleBuffer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_2d(int n0, int n1, DoublePointer in, DoublePointer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_3d(int n0, int n1, int n2, double[] in, double[] out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_3d(int n0, int n1, int n2, DoubleBuffer in, DoubleBuffer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_3d(int n0, int n1, int n2, DoublePointer in, DoublePointer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_1d(int n, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_1d(int n, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_1d(int n, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_2d(int n0, int n1, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_2d(int n0, int n1, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_2d(int n0, int n1, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_3d(int n0, int n1, int n2, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_3d(int n0, int n1, int n2, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r_3d(int n0, int n1, int n2, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r(int rank, int[] n, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r(int rank, IntBuffer n, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_c2r(int rank, IntPointer n, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_1d(int n, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_1d(int n, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_1d(int n, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_2d(int n0, int n1, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_2d(int n0, int n1, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_2d(int n0, int n1, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_3d(int n0, int n1, int n2, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_3d(int n0, int n1, int n2, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c_3d(int n0, int n1, int n2, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c(int rank, int[] n, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c(int rank, IntBuffer n, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft_r2c(int rank, IntPointer n, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft(int rank, int[] n, double[] in, double[] out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft(int rank, IntBuffer n, DoubleBuffer in, DoubleBuffer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_dft(int rank, IntPointer n, DoublePointer in, DoublePointer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, double[] in, double[] out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoubleBuffer in, DoubleBuffer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoublePointer in, DoublePointer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_r2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, double[] in, double[] out, int[] kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_r2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoubleBuffer in, DoubleBuffer out, IntBuffer kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_r2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoublePointer in, DoublePointer out, IntPointer kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, double[] ri, double[] ii, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoubleBuffer ri, DoubleBuffer ii, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoublePointer ri, DoublePointer ii, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, double[] in, double[] ro, double[] io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoubleBuffer in, DoubleBuffer ro, DoubleBuffer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoublePointer in, DoublePointer ro, DoublePointer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, double[] ri, double[] ii, double[] ro, double[] io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoubleBuffer ri, DoubleBuffer ii, DoubleBuffer ro, DoubleBuffer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru_split_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, DoublePointer ri, DoublePointer ii, DoublePointer ro, DoublePointer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, double[] in, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoubleBuffer in, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoublePointer in, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, double[] in, double[] out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoubleBuffer in, DoubleBuffer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoublePointer in, DoublePointer out, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_r2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, double[] in, double[] out, int[] kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_r2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoubleBuffer in, DoubleBuffer out, IntBuffer kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_r2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoublePointer in, DoublePointer out, IntPointer kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, double[] ri, double[] ii, double[] out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoubleBuffer ri, DoubleBuffer ii, DoubleBuffer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoublePointer ri, DoublePointer ii, DoublePointer out, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, double[] in, double[] ro, double[] io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoubleBuffer in, DoubleBuffer ro, DoubleBuffer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoublePointer in, DoublePointer ro, DoublePointer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, double[] ri, double[] ii, double[] ro, double[] io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoubleBuffer ri, DoubleBuffer ii, DoubleBuffer ro, DoubleBuffer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_guru64_split_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, DoublePointer ri, DoublePointer ii, DoublePointer ro, DoublePointer io, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft_c2r(int rank, int[] n, int howmany, double[] in, int[] inembed, int istride, int idist, double[] out, int[] onembed, int ostride, int odist, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft_c2r(int rank, IntBuffer n, int howmany, DoubleBuffer in, IntBuffer inembed, int istride, int idist, DoubleBuffer out, IntBuffer onembed, int ostride, int odist, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft_c2r(int rank, IntPointer n, int howmany, DoublePointer in, IntPointer inembed, int istride, int idist, DoublePointer out, IntPointer onembed, int ostride, int odist, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft_r2c(int rank, int[] n, int howmany, double[] in, int[] inembed, int istride, int idist, double[] out, int[] onembed, int ostride, int odist, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft_r2c(int rank, IntBuffer n, int howmany, DoubleBuffer in, IntBuffer inembed, int istride, int idist, DoubleBuffer out, IntBuffer onembed, int ostride, int odist, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft_r2c(int rank, IntPointer n, int howmany, DoublePointer in, IntPointer inembed, int istride, int idist, DoublePointer out, IntPointer onembed, int ostride, int odist, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft(int rank, int[] n, int howmany, double[] in, int[] inembed, int istride, int idist, double[] out, int[] onembed, int ostride, int odist, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft(int rank, IntBuffer n, int howmany, DoubleBuffer in, IntBuffer inembed, int istride, int idist, DoubleBuffer out, IntBuffer onembed, int ostride, int odist, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_dft(int rank, IntPointer n, int howmany, DoublePointer in, IntPointer inembed, int istride, int idist, DoublePointer out, IntPointer onembed, int ostride, int odist, int sign, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_r2r(int rank, int[] n, int howmany, double[] in, int[] inembed, int istride, int idist, double[] out, int[] onembed, int ostride, int odist, int[] kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_r2r(int rank, IntBuffer n, int howmany, DoubleBuffer in, IntBuffer inembed, int istride, int idist, DoubleBuffer out, IntBuffer onembed, int ostride, int odist, IntBuffer kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_many_r2r(int rank, IntPointer n, int howmany, DoublePointer in, IntPointer inembed, int istride, int idist, DoublePointer out, IntPointer onembed, int ostride, int odist, IntPointer kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_1d(int n, double[] in, double[] out, int kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_1d(int n, DoubleBuffer in, DoubleBuffer out, int kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_1d(int n, DoublePointer in, DoublePointer out, int kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_2d(int n0, int n1, double[] in, double[] out, int kind0, int kind1, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_2d(int n0, int n1, DoubleBuffer in, DoubleBuffer out, int kind0, int kind1, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_2d(int n0, int n1, DoublePointer in, DoublePointer out, int kind0, int kind1, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_3d(int n0, int n1, int n2, double[] in, double[] out, int kind0, int kind1, int kind2, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_3d(int n0, int n1, int n2, DoubleBuffer in, DoubleBuffer out, int kind0, int kind1, int kind2, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r_3d(int n0, int n1, int n2, DoublePointer in, DoublePointer out, int kind0, int kind1, int kind2, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r(int rank, int[] n, double[] in, double[] out, int[] kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r(int rank, IntBuffer n, DoubleBuffer in, DoubleBuffer out, IntBuffer kind, int flags)`
`static fftw3.fftw_plan`	`fftw_plan_r2r(int rank, IntPointer n, DoublePointer in, DoublePointer out, IntPointer kind, int flags)`
`static void`	`fftw_plan_with_nthreads(int nthreads)`
`static int`	`fftw_planner_nthreads()`
`static void`	`fftw_print_plan(fftw3.fftw_plan p)`
`static void`	`fftw_set_timelimit(double t)`
`static BytePointer`	`fftw_sprint_plan(fftw3.fftw_plan p)`
`static void`	`fftw_threads_set_callback(fftw3.Parallel_loop_Work_byte___byte___long_int_Pointer parallel_loop, Pointer data)`
`static void`	`fftw_threads_set_callback(fftw3.Parallel_loop_Work_ByteBuffer_ByteBuffer_long_int_Pointer parallel_loop, Pointer data)`
`static void`	`fftw_threads_set_callback(fftw3.Parallel_loop_Work_BytePointer_BytePointer_long_int_Pointer parallel_loop, Pointer data)`
`static BytePointer`	`fftw_version()`
`static byte`	`fftw_version(int i)`
`static int`	`fftwf_alignment_of(float[] p)`
`static int`	`fftwf_alignment_of(FloatBuffer p)`
`static int`	`fftwf_alignment_of(FloatPointer p)`
`static FloatPointer`	`fftwf_alloc_complex(long n)`
`static FloatPointer`	`fftwf_alloc_real(long n)`
`static BytePointer`	`fftwf_cc()`
`static byte`	`fftwf_cc(int i)`
`static void`	`fftwf_cleanup_threads()`
`static void`	`fftwf_cleanup()`
`static BytePointer`	`fftwf_codelet_optim()`
`static byte`	`fftwf_codelet_optim(int i)`
`static double`	`fftwf_cost(fftw3.fftwf_plan p)`
`static void`	`fftwf_destroy_plan(fftw3.fftwf_plan p)`
`static double`	`fftwf_estimate_cost(fftw3.fftwf_plan p)`
`static void`	`fftwf_execute_dft_c2r(fftw3.fftwf_plan p, float[] in, float[] out)`
`static void`	`fftwf_execute_dft_c2r(fftw3.fftwf_plan p, FloatBuffer in, FloatBuffer out)`
`static void`	`fftwf_execute_dft_c2r(fftw3.fftwf_plan p, FloatPointer in, FloatPointer out)`
`static void`	`fftwf_execute_dft_r2c(fftw3.fftwf_plan p, float[] in, float[] out)`
`static void`	`fftwf_execute_dft_r2c(fftw3.fftwf_plan p, FloatBuffer in, FloatBuffer out)`
`static void`	`fftwf_execute_dft_r2c(fftw3.fftwf_plan p, FloatPointer in, FloatPointer out)`
`static void`	`fftwf_execute_dft(fftw3.fftwf_plan p, float[] in, float[] out)`
`static void`	`fftwf_execute_dft(fftw3.fftwf_plan p, FloatBuffer in, FloatBuffer out)`
`static void`	`fftwf_execute_dft(fftw3.fftwf_plan p, FloatPointer in, FloatPointer out)`
`static void`	`fftwf_execute_r2r(fftw3.fftwf_plan p, float[] in, float[] out)`
`static void`	`fftwf_execute_r2r(fftw3.fftwf_plan p, FloatBuffer in, FloatBuffer out)`
`static void`	`fftwf_execute_r2r(fftw3.fftwf_plan p, FloatPointer in, FloatPointer out)`
`static void`	`fftwf_execute_split_dft_c2r(fftw3.fftwf_plan p, float[] ri, float[] ii, float[] out)`
`static void`	`fftwf_execute_split_dft_c2r(fftw3.fftwf_plan p, FloatBuffer ri, FloatBuffer ii, FloatBuffer out)`
`static void`	`fftwf_execute_split_dft_c2r(fftw3.fftwf_plan p, FloatPointer ri, FloatPointer ii, FloatPointer out)`
`static void`	`fftwf_execute_split_dft_r2c(fftw3.fftwf_plan p, float[] in, float[] ro, float[] io)`
`static void`	`fftwf_execute_split_dft_r2c(fftw3.fftwf_plan p, FloatBuffer in, FloatBuffer ro, FloatBuffer io)`
`static void`	`fftwf_execute_split_dft_r2c(fftw3.fftwf_plan p, FloatPointer in, FloatPointer ro, FloatPointer io)`
`static void`	`fftwf_execute_split_dft(fftw3.fftwf_plan p, float[] ri, float[] ii, float[] ro, float[] io)`
`static void`	`fftwf_execute_split_dft(fftw3.fftwf_plan p, FloatBuffer ri, FloatBuffer ii, FloatBuffer ro, FloatBuffer io)`
`static void`	`fftwf_execute_split_dft(fftw3.fftwf_plan p, FloatPointer ri, FloatPointer ii, FloatPointer ro, FloatPointer io)`
`static void`	`fftwf_execute(fftw3.fftwf_plan p)`
`static void`	`fftwf_export_wisdom_to_file(Pointer output_file)`
`static int`	`fftwf_export_wisdom_to_filename(BytePointer filename)`
`static int`	`fftwf_export_wisdom_to_filename(String filename)`
`static BytePointer`	`fftwf_export_wisdom_to_string()`
`static void`	`fftwf_export_wisdom(fftw3.fftw_write_char_func_do_not_use_me write_char, Pointer data)`
`static void`	`fftwf_flops(fftw3.fftwf_plan p, double[] add, double[] mul, double[] fmas)`
`static void`	`fftwf_flops(fftw3.fftwf_plan p, DoubleBuffer add, DoubleBuffer mul, DoubleBuffer fmas)`
`static void`	`fftwf_flops(fftw3.fftwf_plan p, DoublePointer add, DoublePointer mul, DoublePointer fmas)`
`static void`	`fftwf_forget_wisdom()`
`static void`	`fftwf_fprint_plan(fftw3.fftwf_plan p, Pointer output_file)`
`static void`	`fftwf_free(Pointer p)`
`static int`	`fftwf_import_system_wisdom()`
`static int`	`fftwf_import_wisdom_from_file(Pointer input_file)`
`static int`	`fftwf_import_wisdom_from_filename(BytePointer filename)`
`static int`	`fftwf_import_wisdom_from_filename(String filename)`
`static int`	`fftwf_import_wisdom_from_string(BytePointer input_string)`
`static int`	`fftwf_import_wisdom_from_string(String input_string)`
`static int`	`fftwf_import_wisdom(fftw3.fftw_read_char_func_do_not_use_me read_char, Pointer data)`
`static int`	`fftwf_init_threads()`
`static void`	`fftwf_make_planner_thread_safe()`
`static Pointer`	`fftwf_malloc(long n)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_1d(int n, float[] in, float[] out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_1d(int n, FloatBuffer in, FloatBuffer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_1d(int n, FloatPointer in, FloatPointer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_2d(int n0, int n1, float[] in, float[] out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_2d(int n0, int n1, FloatBuffer in, FloatBuffer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_2d(int n0, int n1, FloatPointer in, FloatPointer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_3d(int n0, int n1, int n2, float[] in, float[] out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_3d(int n0, int n1, int n2, FloatBuffer in, FloatBuffer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_3d(int n0, int n1, int n2, FloatPointer in, FloatPointer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_1d(int n, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_1d(int n, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_1d(int n, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_2d(int n0, int n1, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_2d(int n0, int n1, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_2d(int n0, int n1, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_3d(int n0, int n1, int n2, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_3d(int n0, int n1, int n2, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r_3d(int n0, int n1, int n2, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r(int rank, int[] n, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r(int rank, IntBuffer n, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_c2r(int rank, IntPointer n, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_1d(int n, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_1d(int n, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_1d(int n, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_2d(int n0, int n1, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_2d(int n0, int n1, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_2d(int n0, int n1, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_3d(int n0, int n1, int n2, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_3d(int n0, int n1, int n2, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c_3d(int n0, int n1, int n2, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c(int rank, int[] n, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c(int rank, IntBuffer n, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft_r2c(int rank, IntPointer n, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft(int rank, int[] n, float[] in, float[] out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft(int rank, IntBuffer n, FloatBuffer in, FloatBuffer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_dft(int rank, IntPointer n, FloatPointer in, FloatPointer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, float[] in, float[] out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatBuffer in, FloatBuffer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatPointer in, FloatPointer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_r2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, float[] in, float[] out, int[] kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_r2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatBuffer in, FloatBuffer out, IntBuffer kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_r2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatPointer in, FloatPointer out, IntPointer kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, float[] ri, float[] ii, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatBuffer ri, FloatBuffer ii, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft_c2r(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatPointer ri, FloatPointer ii, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, float[] in, float[] ro, float[] io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatBuffer in, FloatBuffer ro, FloatBuffer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft_r2c(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatPointer in, FloatPointer ro, FloatPointer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, float[] ri, float[] ii, float[] ro, float[] io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatBuffer ri, FloatBuffer ii, FloatBuffer ro, FloatBuffer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru_split_dft(int rank, fftw3.fftw_iodim dims, int howmany_rank, fftw3.fftw_iodim howmany_dims, FloatPointer ri, FloatPointer ii, FloatPointer ro, FloatPointer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, float[] in, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatBuffer in, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatPointer in, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, float[] in, float[] out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatBuffer in, FloatBuffer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatPointer in, FloatPointer out, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_r2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, float[] in, float[] out, int[] kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_r2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatBuffer in, FloatBuffer out, IntBuffer kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_r2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatPointer in, FloatPointer out, IntPointer kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, float[] ri, float[] ii, float[] out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatBuffer ri, FloatBuffer ii, FloatBuffer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft_c2r(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatPointer ri, FloatPointer ii, FloatPointer out, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, float[] in, float[] ro, float[] io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatBuffer in, FloatBuffer ro, FloatBuffer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft_r2c(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatPointer in, FloatPointer ro, FloatPointer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, float[] ri, float[] ii, float[] ro, float[] io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatBuffer ri, FloatBuffer ii, FloatBuffer ro, FloatBuffer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_guru64_split_dft(int rank, fftw3.fftw_iodim64 dims, int howmany_rank, fftw3.fftw_iodim64 howmany_dims, FloatPointer ri, FloatPointer ii, FloatPointer ro, FloatPointer io, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft_c2r(int rank, int[] n, int howmany, float[] in, int[] inembed, int istride, int idist, float[] out, int[] onembed, int ostride, int odist, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft_c2r(int rank, IntBuffer n, int howmany, FloatBuffer in, IntBuffer inembed, int istride, int idist, FloatBuffer out, IntBuffer onembed, int ostride, int odist, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft_c2r(int rank, IntPointer n, int howmany, FloatPointer in, IntPointer inembed, int istride, int idist, FloatPointer out, IntPointer onembed, int ostride, int odist, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft_r2c(int rank, int[] n, int howmany, float[] in, int[] inembed, int istride, int idist, float[] out, int[] onembed, int ostride, int odist, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft_r2c(int rank, IntBuffer n, int howmany, FloatBuffer in, IntBuffer inembed, int istride, int idist, FloatBuffer out, IntBuffer onembed, int ostride, int odist, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft_r2c(int rank, IntPointer n, int howmany, FloatPointer in, IntPointer inembed, int istride, int idist, FloatPointer out, IntPointer onembed, int ostride, int odist, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft(int rank, int[] n, int howmany, float[] in, int[] inembed, int istride, int idist, float[] out, int[] onembed, int ostride, int odist, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft(int rank, IntBuffer n, int howmany, FloatBuffer in, IntBuffer inembed, int istride, int idist, FloatBuffer out, IntBuffer onembed, int ostride, int odist, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_dft(int rank, IntPointer n, int howmany, FloatPointer in, IntPointer inembed, int istride, int idist, FloatPointer out, IntPointer onembed, int ostride, int odist, int sign, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_r2r(int rank, int[] n, int howmany, float[] in, int[] inembed, int istride, int idist, float[] out, int[] onembed, int ostride, int odist, int[] kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_r2r(int rank, IntBuffer n, int howmany, FloatBuffer in, IntBuffer inembed, int istride, int idist, FloatBuffer out, IntBuffer onembed, int ostride, int odist, IntBuffer kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_many_r2r(int rank, IntPointer n, int howmany, FloatPointer in, IntPointer inembed, int istride, int idist, FloatPointer out, IntPointer onembed, int ostride, int odist, IntPointer kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_1d(int n, float[] in, float[] out, int kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_1d(int n, FloatBuffer in, FloatBuffer out, int kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_1d(int n, FloatPointer in, FloatPointer out, int kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_2d(int n0, int n1, float[] in, float[] out, int kind0, int kind1, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_2d(int n0, int n1, FloatBuffer in, FloatBuffer out, int kind0, int kind1, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_2d(int n0, int n1, FloatPointer in, FloatPointer out, int kind0, int kind1, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_3d(int n0, int n1, int n2, float[] in, float[] out, int kind0, int kind1, int kind2, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_3d(int n0, int n1, int n2, FloatBuffer in, FloatBuffer out, int kind0, int kind1, int kind2, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r_3d(int n0, int n1, int n2, FloatPointer in, FloatPointer out, int kind0, int kind1, int kind2, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r(int rank, int[] n, float[] in, float[] out, int[] kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r(int rank, IntBuffer n, FloatBuffer in, FloatBuffer out, IntBuffer kind, int flags)`
`static fftw3.fftwf_plan`	`fftwf_plan_r2r(int rank, IntPointer n, FloatPointer in, FloatPointer out, IntPointer kind, int flags)`
`static void`	`fftwf_plan_with_nthreads(int nthreads)`
`static int`	`fftwf_planner_nthreads()`
`static void`	`fftwf_print_plan(fftw3.fftwf_plan p)`
`static void`	`fftwf_set_timelimit(double t)`
`static BytePointer`	`fftwf_sprint_plan(fftw3.fftwf_plan p)`
`static void`	`fftwf_threads_set_callback(fftw3.Parallel_loop_Work_byte___byte___long_int_Pointer parallel_loop, Pointer data)`
`static void`	`fftwf_threads_set_callback(fftw3.Parallel_loop_Work_ByteBuffer_ByteBuffer_long_int_Pointer parallel_loop, Pointer data)`
`static void`	`fftwf_threads_set_callback(fftw3.Parallel_loop_Work_BytePointer_BytePointer_long_int_Pointer parallel_loop, Pointer data)`
`static BytePointer`	`fftwf_version()`
`static byte`	`fftwf_version(int i)`

Methods inherited from class org.bytedeco.fftw.presets.fftw3
free, map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- FFTW_R2HC
```
public static final int FFTW_R2HC
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_HC2R
```
public static final int FFTW_HC2R
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_DHT
```
public static final int FFTW_DHT
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_REDFT00
```
public static final int FFTW_REDFT00
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_REDFT01
```
public static final int FFTW_REDFT01
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_REDFT10
```
public static final int FFTW_REDFT10
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_REDFT11
```
public static final int FFTW_REDFT11
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_RODFT00
```
public static final int FFTW_RODFT00
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_RODFT01
```
public static final int FFTW_RODFT01
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_RODFT10
```
public static final int FFTW_RODFT10
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_RODFT11
```
public static final int FFTW_RODFT11
```
  enum fftw_r2r_kind_do_not_use_me
  
  See Also:
  
  Constant Field Values
- FFTW_FORWARD
```
public static final int FFTW_FORWARD
```
  See Also:
  
  Constant Field Values
- FFTW_BACKWARD
```
public static final int FFTW_BACKWARD
```
  See Also:
  
  Constant Field Values
- FFTW_NO_TIMELIMIT
```
public static final double FFTW_NO_TIMELIMIT
```
  See Also:
  
  Constant Field Values
- FFTW_MEASURE
```
public static final int FFTW_MEASURE
```
  See Also:
  
  Constant Field Values
- FFTW_DESTROY_INPUT
```
public static final int FFTW_DESTROY_INPUT
```
  See Also:
  
  Constant Field Values
- FFTW_UNALIGNED
```
public static final int FFTW_UNALIGNED
```
  See Also:
  
  Constant Field Values
- FFTW_CONSERVE_MEMORY
```
public static final int FFTW_CONSERVE_MEMORY
```
  See Also:
  
  Constant Field Values
- FFTW_EXHAUSTIVE
```
public static final int FFTW_EXHAUSTIVE
```
  See Also:
  
  Constant Field Values
- FFTW_PRESERVE_INPUT
```
public static final int FFTW_PRESERVE_INPUT
```
  See Also:
  
  Constant Field Values
- FFTW_PATIENT
```
public static final int FFTW_PATIENT
```
  See Also:
  
  Constant Field Values
- FFTW_ESTIMATE
```
public static final int FFTW_ESTIMATE
```
  See Also:
  
  Constant Field Values
- FFTW_WISDOM_ONLY
```
public static final int FFTW_WISDOM_ONLY
```
  See Also:
  
  Constant Field Values
- FFTW_ESTIMATE_PATIENT
```
public static final int FFTW_ESTIMATE_PATIENT
```
  See Also:
  
  Constant Field Values
- FFTW_BELIEVE_PCOST
```
public static final int FFTW_BELIEVE_PCOST
```
  See Also:
  
  Constant Field Values
- FFTW_NO_DFT_R2HC
```
public static final int FFTW_NO_DFT_R2HC
```
  See Also:
  
  Constant Field Values
- FFTW_NO_NONTHREADED
```
public static final int FFTW_NO_NONTHREADED
```
  See Also:
  
  Constant Field Values
- FFTW_NO_BUFFERING
```
public static final int FFTW_NO_BUFFERING
```
  See Also:
  
  Constant Field Values
- FFTW_NO_INDIRECT_OP
```
public static final int FFTW_NO_INDIRECT_OP
```
  See Also:
  
  Constant Field Values
- FFTW_ALLOW_LARGE_GENERIC
```
public static final int FFTW_ALLOW_LARGE_GENERIC
```
  See Also:
  
  Constant Field Values
- FFTW_NO_RANK_SPLITS
```
public static final int FFTW_NO_RANK_SPLITS
```
  See Also:
  
  Constant Field Values
- FFTW_NO_VRANK_SPLITS
```
public static final int FFTW_NO_VRANK_SPLITS
```
  See Also:
  
  Constant Field Values
- FFTW_NO_VRECURSE
```
public static final int FFTW_NO_VRECURSE
```
  See Also:
  
  Constant Field Values
- FFTW_NO_SIMD
```
public static final int FFTW_NO_SIMD
```
  See Also:
  
  Constant Field Values
- FFTW_NO_SLOW
```
public static final int FFTW_NO_SLOW
```
  See Also:
  
  Constant Field Values
- FFTW_NO_FIXED_RADIX_LARGE_N
```
public static final int FFTW_NO_FIXED_RADIX_LARGE_N
```
  See Also:
  
  Constant Field Values
- FFTW_ALLOW_PRUNING
```
public static final int FFTW_ALLOW_PRUNING
```
  See Also:
  
  Constant Field Values

Constructor Detail
- fftw3
```
public fftw3()
```

Method Detail

fftw_execute

public static void fftw_execute(fftw3.fftw_plan p)

fftw_plan_dft

public static fftw3.fftw_plan fftw_plan_dft(int rank,
                                            @Const
                                            IntPointer n,
                                            @Cast(value="fftw_complex*")
                                            DoublePointer in,
                                            @Cast(value="fftw_complex*")
                                            DoublePointer out,
                                            int sign,
                                            @Cast(value="unsigned")
                                            int flags)

fftw_plan_dft

public static fftw3.fftw_plan fftw_plan_dft(int rank,
                                            @Const
                                            IntBuffer n,
                                            @Cast(value="fftw_complex*")
                                            DoubleBuffer in,
                                            @Cast(value="fftw_complex*")
                                            DoubleBuffer out,
                                            int sign,
                                            @Cast(value="unsigned")
                                            int flags)

fftw_plan_dft

public static fftw3.fftw_plan fftw_plan_dft(int rank,
                                            @Const
                                            int[] n,
                                            @Cast(value="fftw_complex*")
                                            double[] in,
                                            @Cast(value="fftw_complex*")
                                            double[] out,
                                            int sign,
                                            @Cast(value="unsigned")
                                            int flags)

fftw_plan_dft_1d

public static fftw3.fftw_plan fftw_plan_dft_1d(int n,
                                               @Cast(value="fftw_complex*")
                                               DoublePointer in,
                                               @Cast(value="fftw_complex*")
                                               DoublePointer out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_1d

public static fftw3.fftw_plan fftw_plan_dft_1d(int n,
                                               @Cast(value="fftw_complex*")
                                               DoubleBuffer in,
                                               @Cast(value="fftw_complex*")
                                               DoubleBuffer out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_1d

public static fftw3.fftw_plan fftw_plan_dft_1d(int n,
                                               @Cast(value="fftw_complex*")
                                               double[] in,
                                               @Cast(value="fftw_complex*")
                                               double[] out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_2d

public static fftw3.fftw_plan fftw_plan_dft_2d(int n0,
                                               int n1,
                                               @Cast(value="fftw_complex*")
                                               DoublePointer in,
                                               @Cast(value="fftw_complex*")
                                               DoublePointer out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_2d

public static fftw3.fftw_plan fftw_plan_dft_2d(int n0,
                                               int n1,
                                               @Cast(value="fftw_complex*")
                                               DoubleBuffer in,
                                               @Cast(value="fftw_complex*")
                                               DoubleBuffer out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_2d

public static fftw3.fftw_plan fftw_plan_dft_2d(int n0,
                                               int n1,
                                               @Cast(value="fftw_complex*")
                                               double[] in,
                                               @Cast(value="fftw_complex*")
                                               double[] out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_3d

public static fftw3.fftw_plan fftw_plan_dft_3d(int n0,
                                               int n1,
                                               int n2,
                                               @Cast(value="fftw_complex*")
                                               DoublePointer in,
                                               @Cast(value="fftw_complex*")
                                               DoublePointer out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_3d

public static fftw3.fftw_plan fftw_plan_dft_3d(int n0,
                                               int n1,
                                               int n2,
                                               @Cast(value="fftw_complex*")
                                               DoubleBuffer in,
                                               @Cast(value="fftw_complex*")
                                               DoubleBuffer out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_dft_3d

public static fftw3.fftw_plan fftw_plan_dft_3d(int n0,
                                               int n1,
                                               int n2,
                                               @Cast(value="fftw_complex*")
                                               double[] in,
                                               @Cast(value="fftw_complex*")
                                               double[] out,
                                               int sign,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_many_dft

public static fftw3.fftw_plan fftw_plan_many_dft(int rank,
                                                 @Const
                                                 IntPointer n,
                                                 int howmany,
                                                 @Cast(value="fftw_complex*")
                                                 DoublePointer in,
                                                 @Const
                                                 IntPointer inembed,
                                                 int istride,
                                                 int idist,
                                                 @Cast(value="fftw_complex*")
                                                 DoublePointer out,
                                                 @Const
                                                 IntPointer onembed,
                                                 int ostride,
                                                 int odist,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_many_dft

public static fftw3.fftw_plan fftw_plan_many_dft(int rank,
                                                 @Const
                                                 IntBuffer n,
                                                 int howmany,
                                                 @Cast(value="fftw_complex*")
                                                 DoubleBuffer in,
                                                 @Const
                                                 IntBuffer inembed,
                                                 int istride,
                                                 int idist,
                                                 @Cast(value="fftw_complex*")
                                                 DoubleBuffer out,
                                                 @Const
                                                 IntBuffer onembed,
                                                 int ostride,
                                                 int odist,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_many_dft

public static fftw3.fftw_plan fftw_plan_many_dft(int rank,
                                                 @Const
                                                 int[] n,
                                                 int howmany,
                                                 @Cast(value="fftw_complex*")
                                                 double[] in,
                                                 @Const
                                                 int[] inembed,
                                                 int istride,
                                                 int idist,
                                                 @Cast(value="fftw_complex*")
                                                 double[] out,
                                                 @Const
                                                 int[] onembed,
                                                 int ostride,
                                                 int odist,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_guru_dft

public static fftw3.fftw_plan fftw_plan_guru_dft(int rank,
                                                 @Const
                                                 fftw3.fftw_iodim dims,
                                                 int howmany_rank,
                                                 @Const
                                                 fftw3.fftw_iodim howmany_dims,
                                                 @Cast(value="fftw_complex*")
                                                 DoublePointer in,
                                                 @Cast(value="fftw_complex*")
                                                 DoublePointer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_guru_dft

public static fftw3.fftw_plan fftw_plan_guru_dft(int rank,
                                                 @Const
                                                 fftw3.fftw_iodim dims,
                                                 int howmany_rank,
                                                 @Const
                                                 fftw3.fftw_iodim howmany_dims,
                                                 @Cast(value="fftw_complex*")
                                                 DoubleBuffer in,
                                                 @Cast(value="fftw_complex*")
                                                 DoubleBuffer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_guru_dft

public static fftw3.fftw_plan fftw_plan_guru_dft(int rank,
                                                 @Const
                                                 fftw3.fftw_iodim dims,
                                                 int howmany_rank,
                                                 @Const
                                                 fftw3.fftw_iodim howmany_dims,
                                                 @Cast(value="fftw_complex*")
                                                 double[] in,
                                                 @Cast(value="fftw_complex*")
                                                 double[] out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_guru_split_dft

public static fftw3.fftw_plan fftw_plan_guru_split_dft(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       DoublePointer ri,
                                                       DoublePointer ii,
                                                       DoublePointer ro,
                                                       DoublePointer io,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru_split_dft

public static fftw3.fftw_plan fftw_plan_guru_split_dft(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       DoubleBuffer ri,
                                                       DoubleBuffer ii,
                                                       DoubleBuffer ro,
                                                       DoubleBuffer io,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru_split_dft

public static fftw3.fftw_plan fftw_plan_guru_split_dft(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       double[] ri,
                                                       double[] ii,
                                                       double[] ro,
                                                       double[] io,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru64_dft

public static fftw3.fftw_plan fftw_plan_guru64_dft(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 howmany_dims,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer out,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_guru64_dft

public static fftw3.fftw_plan fftw_plan_guru64_dft(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 howmany_dims,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer out,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_guru64_dft

public static fftw3.fftw_plan fftw_plan_guru64_dft(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 howmany_dims,
                                                   @Cast(value="fftw_complex*")
                                                   double[] in,
                                                   @Cast(value="fftw_complex*")
                                                   double[] out,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_guru64_split_dft

public static fftw3.fftw_plan fftw_plan_guru64_split_dft(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         DoublePointer ri,
                                                         DoublePointer ii,
                                                         DoublePointer ro,
                                                         DoublePointer io,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftw_plan_guru64_split_dft

public static fftw3.fftw_plan fftw_plan_guru64_split_dft(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         DoubleBuffer ri,
                                                         DoubleBuffer ii,
                                                         DoubleBuffer ro,
                                                         DoubleBuffer io,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftw_plan_guru64_split_dft

public static fftw3.fftw_plan fftw_plan_guru64_split_dft(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         double[] ri,
                                                         double[] ii,
                                                         double[] ro,
                                                         double[] io,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftw_execute_dft

public static void fftw_execute_dft(fftw3.fftw_plan p,
                                    @Cast(value="fftw_complex*")
                                    DoublePointer in,
                                    @Cast(value="fftw_complex*")
                                    DoublePointer out)

fftw_execute_dft

public static void fftw_execute_dft(fftw3.fftw_plan p,
                                    @Cast(value="fftw_complex*")
                                    DoubleBuffer in,
                                    @Cast(value="fftw_complex*")
                                    DoubleBuffer out)

fftw_execute_dft

public static void fftw_execute_dft(fftw3.fftw_plan p,
                                    @Cast(value="fftw_complex*")
                                    double[] in,
                                    @Cast(value="fftw_complex*")
                                    double[] out)

fftw_execute_split_dft

public static void fftw_execute_split_dft(fftw3.fftw_plan p,
                                          DoublePointer ri,
                                          DoublePointer ii,
                                          DoublePointer ro,
                                          DoublePointer io)

fftw_execute_split_dft

public static void fftw_execute_split_dft(fftw3.fftw_plan p,
                                          DoubleBuffer ri,
                                          DoubleBuffer ii,
                                          DoubleBuffer ro,
                                          DoubleBuffer io)

fftw_execute_split_dft

public static void fftw_execute_split_dft(fftw3.fftw_plan p,
                                          double[] ri,
                                          double[] ii,
                                          double[] ro,
                                          double[] io)

fftw_plan_many_dft_r2c

public static fftw3.fftw_plan fftw_plan_many_dft_r2c(int rank,
                                                     @Const
                                                     IntPointer n,
                                                     int howmany,
                                                     DoublePointer in,
                                                     @Const
                                                     IntPointer inembed,
                                                     int istride,
                                                     int idist,
                                                     @Cast(value="fftw_complex*")
                                                     DoublePointer out,
                                                     @Const
                                                     IntPointer onembed,
                                                     int ostride,
                                                     int odist,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_many_dft_r2c

public static fftw3.fftw_plan fftw_plan_many_dft_r2c(int rank,
                                                     @Const
                                                     IntBuffer n,
                                                     int howmany,
                                                     DoubleBuffer in,
                                                     @Const
                                                     IntBuffer inembed,
                                                     int istride,
                                                     int idist,
                                                     @Cast(value="fftw_complex*")
                                                     DoubleBuffer out,
                                                     @Const
                                                     IntBuffer onembed,
                                                     int ostride,
                                                     int odist,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_many_dft_r2c

public static fftw3.fftw_plan fftw_plan_many_dft_r2c(int rank,
                                                     @Const
                                                     int[] n,
                                                     int howmany,
                                                     double[] in,
                                                     @Const
                                                     int[] inembed,
                                                     int istride,
                                                     int idist,
                                                     @Cast(value="fftw_complex*")
                                                     double[] out,
                                                     @Const
                                                     int[] onembed,
                                                     int ostride,
                                                     int odist,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_dft_r2c

public static fftw3.fftw_plan fftw_plan_dft_r2c(int rank,
                                                @Const
                                                IntPointer n,
                                                DoublePointer in,
                                                @Cast(value="fftw_complex*")
                                                DoublePointer out,
                                                @Cast(value="unsigned")
                                                int flags)

fftw_plan_dft_r2c

public static fftw3.fftw_plan fftw_plan_dft_r2c(int rank,
                                                @Const
                                                IntBuffer n,
                                                DoubleBuffer in,
                                                @Cast(value="fftw_complex*")
                                                DoubleBuffer out,
                                                @Cast(value="unsigned")
                                                int flags)

fftw_plan_dft_r2c

public static fftw3.fftw_plan fftw_plan_dft_r2c(int rank,
                                                @Const
                                                int[] n,
                                                double[] in,
                                                @Cast(value="fftw_complex*")
                                                double[] out,
                                                @Cast(value="unsigned")
                                                int flags)

fftw_plan_dft_r2c_1d

public static fftw3.fftw_plan fftw_plan_dft_r2c_1d(int n,
                                                   DoublePointer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_1d

public static fftw3.fftw_plan fftw_plan_dft_r2c_1d(int n,
                                                   DoubleBuffer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_1d

public static fftw3.fftw_plan fftw_plan_dft_r2c_1d(int n,
                                                   double[] in,
                                                   @Cast(value="fftw_complex*")
                                                   double[] out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_2d

public static fftw3.fftw_plan fftw_plan_dft_r2c_2d(int n0,
                                                   int n1,
                                                   DoublePointer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_2d

public static fftw3.fftw_plan fftw_plan_dft_r2c_2d(int n0,
                                                   int n1,
                                                   DoubleBuffer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_2d

public static fftw3.fftw_plan fftw_plan_dft_r2c_2d(int n0,
                                                   int n1,
                                                   double[] in,
                                                   @Cast(value="fftw_complex*")
                                                   double[] out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_3d

public static fftw3.fftw_plan fftw_plan_dft_r2c_3d(int n0,
                                                   int n1,
                                                   int n2,
                                                   DoublePointer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_3d

public static fftw3.fftw_plan fftw_plan_dft_r2c_3d(int n0,
                                                   int n1,
                                                   int n2,
                                                   DoubleBuffer in,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_r2c_3d

public static fftw3.fftw_plan fftw_plan_dft_r2c_3d(int n0,
                                                   int n1,
                                                   int n2,
                                                   double[] in,
                                                   @Cast(value="fftw_complex*")
                                                   double[] out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_many_dft_c2r

public static fftw3.fftw_plan fftw_plan_many_dft_c2r(int rank,
                                                     @Const
                                                     IntPointer n,
                                                     int howmany,
                                                     @Cast(value="fftw_complex*")
                                                     DoublePointer in,
                                                     @Const
                                                     IntPointer inembed,
                                                     int istride,
                                                     int idist,
                                                     DoublePointer out,
                                                     @Const
                                                     IntPointer onembed,
                                                     int ostride,
                                                     int odist,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_many_dft_c2r

public static fftw3.fftw_plan fftw_plan_many_dft_c2r(int rank,
                                                     @Const
                                                     IntBuffer n,
                                                     int howmany,
                                                     @Cast(value="fftw_complex*")
                                                     DoubleBuffer in,
                                                     @Const
                                                     IntBuffer inembed,
                                                     int istride,
                                                     int idist,
                                                     DoubleBuffer out,
                                                     @Const
                                                     IntBuffer onembed,
                                                     int ostride,
                                                     int odist,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_many_dft_c2r

public static fftw3.fftw_plan fftw_plan_many_dft_c2r(int rank,
                                                     @Const
                                                     int[] n,
                                                     int howmany,
                                                     @Cast(value="fftw_complex*")
                                                     double[] in,
                                                     @Const
                                                     int[] inembed,
                                                     int istride,
                                                     int idist,
                                                     double[] out,
                                                     @Const
                                                     int[] onembed,
                                                     int ostride,
                                                     int odist,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_dft_c2r

public static fftw3.fftw_plan fftw_plan_dft_c2r(int rank,
                                                @Const
                                                IntPointer n,
                                                @Cast(value="fftw_complex*")
                                                DoublePointer in,
                                                DoublePointer out,
                                                @Cast(value="unsigned")
                                                int flags)

fftw_plan_dft_c2r

public static fftw3.fftw_plan fftw_plan_dft_c2r(int rank,
                                                @Const
                                                IntBuffer n,
                                                @Cast(value="fftw_complex*")
                                                DoubleBuffer in,
                                                DoubleBuffer out,
                                                @Cast(value="unsigned")
                                                int flags)

fftw_plan_dft_c2r

public static fftw3.fftw_plan fftw_plan_dft_c2r(int rank,
                                                @Const
                                                int[] n,
                                                @Cast(value="fftw_complex*")
                                                double[] in,
                                                double[] out,
                                                @Cast(value="unsigned")
                                                int flags)

fftw_plan_dft_c2r_1d

public static fftw3.fftw_plan fftw_plan_dft_c2r_1d(int n,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer in,
                                                   DoublePointer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_1d

public static fftw3.fftw_plan fftw_plan_dft_c2r_1d(int n,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer in,
                                                   DoubleBuffer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_1d

public static fftw3.fftw_plan fftw_plan_dft_c2r_1d(int n,
                                                   @Cast(value="fftw_complex*")
                                                   double[] in,
                                                   double[] out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_2d

public static fftw3.fftw_plan fftw_plan_dft_c2r_2d(int n0,
                                                   int n1,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer in,
                                                   DoublePointer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_2d

public static fftw3.fftw_plan fftw_plan_dft_c2r_2d(int n0,
                                                   int n1,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer in,
                                                   DoubleBuffer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_2d

public static fftw3.fftw_plan fftw_plan_dft_c2r_2d(int n0,
                                                   int n1,
                                                   @Cast(value="fftw_complex*")
                                                   double[] in,
                                                   double[] out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_3d

public static fftw3.fftw_plan fftw_plan_dft_c2r_3d(int n0,
                                                   int n1,
                                                   int n2,
                                                   @Cast(value="fftw_complex*")
                                                   DoublePointer in,
                                                   DoublePointer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_3d

public static fftw3.fftw_plan fftw_plan_dft_c2r_3d(int n0,
                                                   int n1,
                                                   int n2,
                                                   @Cast(value="fftw_complex*")
                                                   DoubleBuffer in,
                                                   DoubleBuffer out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_dft_c2r_3d

public static fftw3.fftw_plan fftw_plan_dft_c2r_3d(int n0,
                                                   int n1,
                                                   int n2,
                                                   @Cast(value="fftw_complex*")
                                                   double[] in,
                                                   double[] out,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_guru_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru_dft_r2c(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim howmany_dims,
                                                     DoublePointer in,
                                                     @Cast(value="fftw_complex*")
                                                     DoublePointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_guru_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru_dft_r2c(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim howmany_dims,
                                                     DoubleBuffer in,
                                                     @Cast(value="fftw_complex*")
                                                     DoubleBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_guru_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru_dft_r2c(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim howmany_dims,
                                                     double[] in,
                                                     @Cast(value="fftw_complex*")
                                                     double[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_guru_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru_dft_c2r(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim howmany_dims,
                                                     @Cast(value="fftw_complex*")
                                                     DoublePointer in,
                                                     DoublePointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_guru_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru_dft_c2r(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim howmany_dims,
                                                     @Cast(value="fftw_complex*")
                                                     DoubleBuffer in,
                                                     DoubleBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_guru_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru_dft_c2r(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim howmany_dims,
                                                     @Cast(value="fftw_complex*")
                                                     double[] in,
                                                     double[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftw_plan_guru_split_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru_split_dft_r2c(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim howmany_dims,
                                                           DoublePointer in,
                                                           DoublePointer ro,
                                                           DoublePointer io,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftw_plan_guru_split_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru_split_dft_r2c(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim howmany_dims,
                                                           DoubleBuffer in,
                                                           DoubleBuffer ro,
                                                           DoubleBuffer io,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftw_plan_guru_split_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru_split_dft_r2c(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim howmany_dims,
                                                           double[] in,
                                                           double[] ro,
                                                           double[] io,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftw_plan_guru_split_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru_split_dft_c2r(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim howmany_dims,
                                                           DoublePointer ri,
                                                           DoublePointer ii,
                                                           DoublePointer out,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftw_plan_guru_split_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru_split_dft_c2r(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim howmany_dims,
                                                           DoubleBuffer ri,
                                                           DoubleBuffer ii,
                                                           DoubleBuffer out,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftw_plan_guru_split_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru_split_dft_c2r(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim howmany_dims,
                                                           double[] ri,
                                                           double[] ii,
                                                           double[] out,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftw_plan_guru64_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru64_dft_r2c(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 howmany_dims,
                                                       DoublePointer in,
                                                       @Cast(value="fftw_complex*")
                                                       DoublePointer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru64_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru64_dft_r2c(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 howmany_dims,
                                                       DoubleBuffer in,
                                                       @Cast(value="fftw_complex*")
                                                       DoubleBuffer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru64_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru64_dft_r2c(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 howmany_dims,
                                                       double[] in,
                                                       @Cast(value="fftw_complex*")
                                                       double[] out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru64_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru64_dft_c2r(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 howmany_dims,
                                                       @Cast(value="fftw_complex*")
                                                       DoublePointer in,
                                                       DoublePointer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru64_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru64_dft_c2r(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 howmany_dims,
                                                       @Cast(value="fftw_complex*")
                                                       DoubleBuffer in,
                                                       DoubleBuffer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru64_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru64_dft_c2r(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim64 howmany_dims,
                                                       @Cast(value="fftw_complex*")
                                                       double[] in,
                                                       double[] out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftw_plan_guru64_split_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru64_split_dft_r2c(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 howmany_dims,
                                                             DoublePointer in,
                                                             DoublePointer ro,
                                                             DoublePointer io,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftw_plan_guru64_split_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru64_split_dft_r2c(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 howmany_dims,
                                                             DoubleBuffer in,
                                                             DoubleBuffer ro,
                                                             DoubleBuffer io,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftw_plan_guru64_split_dft_r2c

public static fftw3.fftw_plan fftw_plan_guru64_split_dft_r2c(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 howmany_dims,
                                                             double[] in,
                                                             double[] ro,
                                                             double[] io,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftw_plan_guru64_split_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru64_split_dft_c2r(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 howmany_dims,
                                                             DoublePointer ri,
                                                             DoublePointer ii,
                                                             DoublePointer out,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftw_plan_guru64_split_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru64_split_dft_c2r(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 howmany_dims,
                                                             DoubleBuffer ri,
                                                             DoubleBuffer ii,
                                                             DoubleBuffer out,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftw_plan_guru64_split_dft_c2r

public static fftw3.fftw_plan fftw_plan_guru64_split_dft_c2r(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim64 howmany_dims,
                                                             double[] ri,
                                                             double[] ii,
                                                             double[] out,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftw_execute_dft_r2c

public static void fftw_execute_dft_r2c(fftw3.fftw_plan p,
                                        DoublePointer in,
                                        @Cast(value="fftw_complex*")
                                        DoublePointer out)

fftw_execute_dft_r2c

public static void fftw_execute_dft_r2c(fftw3.fftw_plan p,
                                        DoubleBuffer in,
                                        @Cast(value="fftw_complex*")
                                        DoubleBuffer out)

fftw_execute_dft_r2c

public static void fftw_execute_dft_r2c(fftw3.fftw_plan p,
                                        double[] in,
                                        @Cast(value="fftw_complex*")
                                        double[] out)

fftw_execute_dft_c2r

public static void fftw_execute_dft_c2r(fftw3.fftw_plan p,
                                        @Cast(value="fftw_complex*")
                                        DoublePointer in,
                                        DoublePointer out)

fftw_execute_dft_c2r

public static void fftw_execute_dft_c2r(fftw3.fftw_plan p,
                                        @Cast(value="fftw_complex*")
                                        DoubleBuffer in,
                                        DoubleBuffer out)

fftw_execute_dft_c2r

public static void fftw_execute_dft_c2r(fftw3.fftw_plan p,
                                        @Cast(value="fftw_complex*")
                                        double[] in,
                                        double[] out)

fftw_execute_split_dft_r2c

public static void fftw_execute_split_dft_r2c(fftw3.fftw_plan p,
                                              DoublePointer in,
                                              DoublePointer ro,
                                              DoublePointer io)

fftw_execute_split_dft_r2c

public static void fftw_execute_split_dft_r2c(fftw3.fftw_plan p,
                                              DoubleBuffer in,
                                              DoubleBuffer ro,
                                              DoubleBuffer io)

fftw_execute_split_dft_r2c

public static void fftw_execute_split_dft_r2c(fftw3.fftw_plan p,
                                              double[] in,
                                              double[] ro,
                                              double[] io)

fftw_execute_split_dft_c2r

public static void fftw_execute_split_dft_c2r(fftw3.fftw_plan p,
                                              DoublePointer ri,
                                              DoublePointer ii,
                                              DoublePointer out)

fftw_execute_split_dft_c2r

public static void fftw_execute_split_dft_c2r(fftw3.fftw_plan p,
                                              DoubleBuffer ri,
                                              DoubleBuffer ii,
                                              DoubleBuffer out)

fftw_execute_split_dft_c2r

public static void fftw_execute_split_dft_c2r(fftw3.fftw_plan p,
                                              double[] ri,
                                              double[] ii,
                                              double[] out)

fftw_plan_many_r2r

public static fftw3.fftw_plan fftw_plan_many_r2r(int rank,
                                                 @Const
                                                 IntPointer n,
                                                 int howmany,
                                                 DoublePointer in,
                                                 @Const
                                                 IntPointer inembed,
                                                 int istride,
                                                 int idist,
                                                 DoublePointer out,
                                                 @Const
                                                 IntPointer onembed,
                                                 int ostride,
                                                 int odist,
                                                 @Cast(value="const fftw_r2r_kind*")
                                                 IntPointer kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_many_r2r

public static fftw3.fftw_plan fftw_plan_many_r2r(int rank,
                                                 @Const
                                                 IntBuffer n,
                                                 int howmany,
                                                 DoubleBuffer in,
                                                 @Const
                                                 IntBuffer inembed,
                                                 int istride,
                                                 int idist,
                                                 DoubleBuffer out,
                                                 @Const
                                                 IntBuffer onembed,
                                                 int ostride,
                                                 int odist,
                                                 @Cast(value="const fftw_r2r_kind*")
                                                 IntBuffer kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_many_r2r

public static fftw3.fftw_plan fftw_plan_many_r2r(int rank,
                                                 @Const
                                                 int[] n,
                                                 int howmany,
                                                 double[] in,
                                                 @Const
                                                 int[] inembed,
                                                 int istride,
                                                 int idist,
                                                 double[] out,
                                                 @Const
                                                 int[] onembed,
                                                 int ostride,
                                                 int odist,
                                                 @Cast(value="const fftw_r2r_kind*")
                                                 int[] kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_r2r

public static fftw3.fftw_plan fftw_plan_r2r(int rank,
                                            @Const
                                            IntPointer n,
                                            DoublePointer in,
                                            DoublePointer out,
                                            @Cast(value="const fftw_r2r_kind*")
                                            IntPointer kind,
                                            @Cast(value="unsigned")
                                            int flags)

fftw_plan_r2r

public static fftw3.fftw_plan fftw_plan_r2r(int rank,
                                            @Const
                                            IntBuffer n,
                                            DoubleBuffer in,
                                            DoubleBuffer out,
                                            @Cast(value="const fftw_r2r_kind*")
                                            IntBuffer kind,
                                            @Cast(value="unsigned")
                                            int flags)

fftw_plan_r2r

public static fftw3.fftw_plan fftw_plan_r2r(int rank,
                                            @Const
                                            int[] n,
                                            double[] in,
                                            double[] out,
                                            @Cast(value="const fftw_r2r_kind*")
                                            int[] kind,
                                            @Cast(value="unsigned")
                                            int flags)

fftw_plan_r2r_1d

public static fftw3.fftw_plan fftw_plan_r2r_1d(int n,
                                               DoublePointer in,
                                               DoublePointer out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_1d

public static fftw3.fftw_plan fftw_plan_r2r_1d(int n,
                                               DoubleBuffer in,
                                               DoubleBuffer out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_1d

public static fftw3.fftw_plan fftw_plan_r2r_1d(int n,
                                               double[] in,
                                               double[] out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_2d

public static fftw3.fftw_plan fftw_plan_r2r_2d(int n0,
                                               int n1,
                                               DoublePointer in,
                                               DoublePointer out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind0,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind1,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_2d

public static fftw3.fftw_plan fftw_plan_r2r_2d(int n0,
                                               int n1,
                                               DoubleBuffer in,
                                               DoubleBuffer out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind0,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind1,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_2d

public static fftw3.fftw_plan fftw_plan_r2r_2d(int n0,
                                               int n1,
                                               double[] in,
                                               double[] out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind0,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind1,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_3d

public static fftw3.fftw_plan fftw_plan_r2r_3d(int n0,
                                               int n1,
                                               int n2,
                                               DoublePointer in,
                                               DoublePointer out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind0,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind1,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind2,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_3d

public static fftw3.fftw_plan fftw_plan_r2r_3d(int n0,
                                               int n1,
                                               int n2,
                                               DoubleBuffer in,
                                               DoubleBuffer out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind0,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind1,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind2,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_r2r_3d

public static fftw3.fftw_plan fftw_plan_r2r_3d(int n0,
                                               int n1,
                                               int n2,
                                               double[] in,
                                               double[] out,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind0,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind1,
                                               @Cast(value="fftw_r2r_kind")
                                               int kind2,
                                               @Cast(value="unsigned")
                                               int flags)

fftw_plan_guru_r2r

public static fftw3.fftw_plan fftw_plan_guru_r2r(int rank,
                                                 @Const
                                                 fftw3.fftw_iodim dims,
                                                 int howmany_rank,
                                                 @Const
                                                 fftw3.fftw_iodim howmany_dims,
                                                 DoublePointer in,
                                                 DoublePointer out,
                                                 @Cast(value="const fftw_r2r_kind*")
                                                 IntPointer kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_guru_r2r

public static fftw3.fftw_plan fftw_plan_guru_r2r(int rank,
                                                 @Const
                                                 fftw3.fftw_iodim dims,
                                                 int howmany_rank,
                                                 @Const
                                                 fftw3.fftw_iodim howmany_dims,
                                                 DoubleBuffer in,
                                                 DoubleBuffer out,
                                                 @Cast(value="const fftw_r2r_kind*")
                                                 IntBuffer kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_guru_r2r

public static fftw3.fftw_plan fftw_plan_guru_r2r(int rank,
                                                 @Const
                                                 fftw3.fftw_iodim dims,
                                                 int howmany_rank,
                                                 @Const
                                                 fftw3.fftw_iodim howmany_dims,
                                                 double[] in,
                                                 double[] out,
                                                 @Cast(value="const fftw_r2r_kind*")
                                                 int[] kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftw_plan_guru64_r2r

public static fftw3.fftw_plan fftw_plan_guru64_r2r(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 howmany_dims,
                                                   DoublePointer in,
                                                   DoublePointer out,
                                                   @Cast(value="const fftw_r2r_kind*")
                                                   IntPointer kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_guru64_r2r

public static fftw3.fftw_plan fftw_plan_guru64_r2r(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 howmany_dims,
                                                   DoubleBuffer in,
                                                   DoubleBuffer out,
                                                   @Cast(value="const fftw_r2r_kind*")
                                                   IntBuffer kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_plan_guru64_r2r

public static fftw3.fftw_plan fftw_plan_guru64_r2r(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim64 howmany_dims,
                                                   double[] in,
                                                   double[] out,
                                                   @Cast(value="const fftw_r2r_kind*")
                                                   int[] kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftw_execute_r2r

public static void fftw_execute_r2r(fftw3.fftw_plan p,
                                    DoublePointer in,
                                    DoublePointer out)

fftw_execute_r2r

public static void fftw_execute_r2r(fftw3.fftw_plan p,
                                    DoubleBuffer in,
                                    DoubleBuffer out)

fftw_execute_r2r

public static void fftw_execute_r2r(fftw3.fftw_plan p,
                                    double[] in,
                                    double[] out)

fftw_destroy_plan

public static void fftw_destroy_plan(fftw3.fftw_plan p)

fftw_forget_wisdom

public static void fftw_forget_wisdom()

fftw_cleanup
```
public static void fftw_cleanup()
```

fftw_set_timelimit

public static void fftw_set_timelimit(double t)

fftw_plan_with_nthreads

public static void fftw_plan_with_nthreads(int nthreads)

fftw_planner_nthreads

public static int fftw_planner_nthreads()

fftw_init_threads
```
public static int fftw_init_threads()
```

fftw_cleanup_threads

public static void fftw_cleanup_threads()

fftw_threads_set_callback

public static void fftw_threads_set_callback(fftw3.Parallel_loop_Work_BytePointer_BytePointer_long_int_Pointer parallel_loop,
                                             Pointer data)

fftw_threads_set_callback

public static void fftw_threads_set_callback(fftw3.Parallel_loop_Work_ByteBuffer_ByteBuffer_long_int_Pointer parallel_loop,
                                             Pointer data)

fftw_threads_set_callback

public static void fftw_threads_set_callback(fftw3.Parallel_loop_Work_byte___byte___long_int_Pointer parallel_loop,
                                             Pointer data)

fftw_make_planner_thread_safe

public static void fftw_make_planner_thread_safe()

fftw_export_wisdom_to_filename

public static int fftw_export_wisdom_to_filename(@Cast(value="const char*")
                                                 BytePointer filename)

fftw_export_wisdom_to_filename

public static int fftw_export_wisdom_to_filename(String filename)

fftw_export_wisdom_to_file

public static void fftw_export_wisdom_to_file(@Cast(value="FILE*")
                                              Pointer output_file)

fftw_export_wisdom_to_string

@Cast(value="char*")
public static BytePointer fftw_export_wisdom_to_string()

fftw_export_wisdom

public static void fftw_export_wisdom(@Cast(value="fftw_write_char_func")
                                      fftw3.fftw_write_char_func_do_not_use_me write_char,
                                      Pointer data)

fftw_import_system_wisdom

public static int fftw_import_system_wisdom()

fftw_import_wisdom_from_filename

public static int fftw_import_wisdom_from_filename(@Cast(value="const char*")
                                                   BytePointer filename)

fftw_import_wisdom_from_filename

public static int fftw_import_wisdom_from_filename(String filename)

fftw_import_wisdom_from_file

public static int fftw_import_wisdom_from_file(@Cast(value="FILE*")
                                               Pointer input_file)

fftw_import_wisdom_from_string

public static int fftw_import_wisdom_from_string(@Cast(value="const char*")
                                                 BytePointer input_string)

fftw_import_wisdom_from_string

public static int fftw_import_wisdom_from_string(String input_string)

fftw_import_wisdom

public static int fftw_import_wisdom(@Cast(value="fftw_read_char_func")
                                     fftw3.fftw_read_char_func_do_not_use_me read_char,
                                     Pointer data)

fftw_fprint_plan

public static void fftw_fprint_plan(fftw3.fftw_plan p,
                                    @Cast(value="FILE*")
                                    Pointer output_file)

fftw_print_plan

public static void fftw_print_plan(fftw3.fftw_plan p)

fftw_sprint_plan

@Cast(value="char*")
public static BytePointer fftw_sprint_plan(fftw3.fftw_plan p)

fftw_malloc

public static Pointer fftw_malloc(@Cast(value="size_t")
                                  long n)

fftw_alloc_real

public static DoublePointer fftw_alloc_real(@Cast(value="size_t")
                                            long n)

fftw_alloc_complex

@Cast(value="fftw_complex*")
public static DoublePointer fftw_alloc_complex(@Cast(value="size_t")
                                                                            long n)

fftw_free

public static void fftw_free(Pointer p)

fftw_flops

public static void fftw_flops(fftw3.fftw_plan p,
                              DoublePointer add,
                              DoublePointer mul,
                              DoublePointer fmas)

fftw_flops

public static void fftw_flops(fftw3.fftw_plan p,
                              DoubleBuffer add,
                              DoubleBuffer mul,
                              DoubleBuffer fmas)

fftw_flops

public static void fftw_flops(fftw3.fftw_plan p,
                              double[] add,
                              double[] mul,
                              double[] fmas)

fftw_estimate_cost

public static double fftw_estimate_cost(fftw3.fftw_plan p)

fftw_cost

public static double fftw_cost(fftw3.fftw_plan p)

fftw_alignment_of

public static int fftw_alignment_of(DoublePointer p)

fftw_alignment_of

public static int fftw_alignment_of(DoubleBuffer p)

fftw_alignment_of

public static int fftw_alignment_of(double[] p)

fftw_version

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char")
public static byte fftw_version(int i)

fftw_version

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char*")
public static BytePointer fftw_version()

fftw_cc

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char")
public static byte fftw_cc(int i)

fftw_cc

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char*")
public static BytePointer fftw_cc()

fftw_codelet_optim

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char")
public static byte fftw_codelet_optim(int i)

fftw_codelet_optim

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char*")
public static BytePointer fftw_codelet_optim()

fftwf_execute

public static void fftwf_execute(fftw3.fftwf_plan p)

fftwf_plan_dft

public static fftw3.fftwf_plan fftwf_plan_dft(int rank,
                                              @Const
                                              IntPointer n,
                                              @Cast(value="fftwf_complex*")
                                              FloatPointer in,
                                              @Cast(value="fftwf_complex*")
                                              FloatPointer out,
                                              int sign,
                                              @Cast(value="unsigned")
                                              int flags)

fftwf_plan_dft

public static fftw3.fftwf_plan fftwf_plan_dft(int rank,
                                              @Const
                                              IntBuffer n,
                                              @Cast(value="fftwf_complex*")
                                              FloatBuffer in,
                                              @Cast(value="fftwf_complex*")
                                              FloatBuffer out,
                                              int sign,
                                              @Cast(value="unsigned")
                                              int flags)

fftwf_plan_dft

public static fftw3.fftwf_plan fftwf_plan_dft(int rank,
                                              @Const
                                              int[] n,
                                              @Cast(value="fftwf_complex*")
                                              float[] in,
                                              @Cast(value="fftwf_complex*")
                                              float[] out,
                                              int sign,
                                              @Cast(value="unsigned")
                                              int flags)

fftwf_plan_dft_1d

public static fftw3.fftwf_plan fftwf_plan_dft_1d(int n,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatPointer in,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatPointer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_1d

public static fftw3.fftwf_plan fftwf_plan_dft_1d(int n,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatBuffer in,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatBuffer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_1d

public static fftw3.fftwf_plan fftwf_plan_dft_1d(int n,
                                                 @Cast(value="fftwf_complex*")
                                                 float[] in,
                                                 @Cast(value="fftwf_complex*")
                                                 float[] out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_2d

public static fftw3.fftwf_plan fftwf_plan_dft_2d(int n0,
                                                 int n1,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatPointer in,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatPointer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_2d

public static fftw3.fftwf_plan fftwf_plan_dft_2d(int n0,
                                                 int n1,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatBuffer in,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatBuffer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_2d

public static fftw3.fftwf_plan fftwf_plan_dft_2d(int n0,
                                                 int n1,
                                                 @Cast(value="fftwf_complex*")
                                                 float[] in,
                                                 @Cast(value="fftwf_complex*")
                                                 float[] out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_3d

public static fftw3.fftwf_plan fftwf_plan_dft_3d(int n0,
                                                 int n1,
                                                 int n2,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatPointer in,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatPointer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_3d

public static fftw3.fftwf_plan fftwf_plan_dft_3d(int n0,
                                                 int n1,
                                                 int n2,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatBuffer in,
                                                 @Cast(value="fftwf_complex*")
                                                 FloatBuffer out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_dft_3d

public static fftw3.fftwf_plan fftwf_plan_dft_3d(int n0,
                                                 int n1,
                                                 int n2,
                                                 @Cast(value="fftwf_complex*")
                                                 float[] in,
                                                 @Cast(value="fftwf_complex*")
                                                 float[] out,
                                                 int sign,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_many_dft

public static fftw3.fftwf_plan fftwf_plan_many_dft(int rank,
                                                   @Const
                                                   IntPointer n,
                                                   int howmany,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatPointer in,
                                                   @Const
                                                   IntPointer inembed,
                                                   int istride,
                                                   int idist,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatPointer out,
                                                   @Const
                                                   IntPointer onembed,
                                                   int ostride,
                                                   int odist,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_many_dft

public static fftw3.fftwf_plan fftwf_plan_many_dft(int rank,
                                                   @Const
                                                   IntBuffer n,
                                                   int howmany,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatBuffer in,
                                                   @Const
                                                   IntBuffer inembed,
                                                   int istride,
                                                   int idist,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatBuffer out,
                                                   @Const
                                                   IntBuffer onembed,
                                                   int ostride,
                                                   int odist,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_many_dft

public static fftw3.fftwf_plan fftwf_plan_many_dft(int rank,
                                                   @Const
                                                   int[] n,
                                                   int howmany,
                                                   @Cast(value="fftwf_complex*")
                                                   float[] in,
                                                   @Const
                                                   int[] inembed,
                                                   int istride,
                                                   int idist,
                                                   @Cast(value="fftwf_complex*")
                                                   float[] out,
                                                   @Const
                                                   int[] onembed,
                                                   int ostride,
                                                   int odist,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_guru_dft

public static fftw3.fftwf_plan fftwf_plan_guru_dft(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim howmany_dims,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatPointer in,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatPointer out,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_guru_dft

public static fftw3.fftwf_plan fftwf_plan_guru_dft(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim howmany_dims,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatBuffer in,
                                                   @Cast(value="fftwf_complex*")
                                                   FloatBuffer out,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_guru_dft

public static fftw3.fftwf_plan fftwf_plan_guru_dft(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim howmany_dims,
                                                   @Cast(value="fftwf_complex*")
                                                   float[] in,
                                                   @Cast(value="fftwf_complex*")
                                                   float[] out,
                                                   int sign,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_guru_split_dft

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim howmany_dims,
                                                         FloatPointer ri,
                                                         FloatPointer ii,
                                                         FloatPointer ro,
                                                         FloatPointer io,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru_split_dft

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim howmany_dims,
                                                         FloatBuffer ri,
                                                         FloatBuffer ii,
                                                         FloatBuffer ro,
                                                         FloatBuffer io,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru_split_dft

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim howmany_dims,
                                                         float[] ri,
                                                         float[] ii,
                                                         float[] ro,
                                                         float[] io,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru64_dft

public static fftw3.fftwf_plan fftwf_plan_guru64_dft(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 howmany_dims,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer out,
                                                     int sign,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_guru64_dft

public static fftw3.fftwf_plan fftwf_plan_guru64_dft(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 howmany_dims,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer out,
                                                     int sign,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_guru64_dft

public static fftw3.fftwf_plan fftwf_plan_guru64_dft(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 howmany_dims,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] in,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] out,
                                                     int sign,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_guru64_split_dft

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim64 dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim64 howmany_dims,
                                                           FloatPointer ri,
                                                           FloatPointer ii,
                                                           FloatPointer ro,
                                                           FloatPointer io,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftwf_plan_guru64_split_dft

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim64 dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim64 howmany_dims,
                                                           FloatBuffer ri,
                                                           FloatBuffer ii,
                                                           FloatBuffer ro,
                                                           FloatBuffer io,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftwf_plan_guru64_split_dft

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft(int rank,
                                                           @Const
                                                           fftw3.fftw_iodim64 dims,
                                                           int howmany_rank,
                                                           @Const
                                                           fftw3.fftw_iodim64 howmany_dims,
                                                           float[] ri,
                                                           float[] ii,
                                                           float[] ro,
                                                           float[] io,
                                                           @Cast(value="unsigned")
                                                           int flags)

fftwf_execute_dft

public static void fftwf_execute_dft(fftw3.fftwf_plan p,
                                     @Cast(value="fftwf_complex*")
                                     FloatPointer in,
                                     @Cast(value="fftwf_complex*")
                                     FloatPointer out)

fftwf_execute_dft

public static void fftwf_execute_dft(fftw3.fftwf_plan p,
                                     @Cast(value="fftwf_complex*")
                                     FloatBuffer in,
                                     @Cast(value="fftwf_complex*")
                                     FloatBuffer out)

fftwf_execute_dft

public static void fftwf_execute_dft(fftw3.fftwf_plan p,
                                     @Cast(value="fftwf_complex*")
                                     float[] in,
                                     @Cast(value="fftwf_complex*")
                                     float[] out)

fftwf_execute_split_dft

public static void fftwf_execute_split_dft(fftw3.fftwf_plan p,
                                           FloatPointer ri,
                                           FloatPointer ii,
                                           FloatPointer ro,
                                           FloatPointer io)

fftwf_execute_split_dft

public static void fftwf_execute_split_dft(fftw3.fftwf_plan p,
                                           FloatBuffer ri,
                                           FloatBuffer ii,
                                           FloatBuffer ro,
                                           FloatBuffer io)

fftwf_execute_split_dft

public static void fftwf_execute_split_dft(fftw3.fftwf_plan p,
                                           float[] ri,
                                           float[] ii,
                                           float[] ro,
                                           float[] io)

fftwf_plan_many_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_many_dft_r2c(int rank,
                                                       @Const
                                                       IntPointer n,
                                                       int howmany,
                                                       FloatPointer in,
                                                       @Const
                                                       IntPointer inembed,
                                                       int istride,
                                                       int idist,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatPointer out,
                                                       @Const
                                                       IntPointer onembed,
                                                       int ostride,
                                                       int odist,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_many_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_many_dft_r2c(int rank,
                                                       @Const
                                                       IntBuffer n,
                                                       int howmany,
                                                       FloatBuffer in,
                                                       @Const
                                                       IntBuffer inembed,
                                                       int istride,
                                                       int idist,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatBuffer out,
                                                       @Const
                                                       IntBuffer onembed,
                                                       int ostride,
                                                       int odist,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_many_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_many_dft_r2c(int rank,
                                                       @Const
                                                       int[] n,
                                                       int howmany,
                                                       float[] in,
                                                       @Const
                                                       int[] inembed,
                                                       int istride,
                                                       int idist,
                                                       @Cast(value="fftwf_complex*")
                                                       float[] out,
                                                       @Const
                                                       int[] onembed,
                                                       int ostride,
                                                       int odist,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_dft_r2c(int rank,
                                                  @Const
                                                  IntPointer n,
                                                  FloatPointer in,
                                                  @Cast(value="fftwf_complex*")
                                                  FloatPointer out,
                                                  @Cast(value="unsigned")
                                                  int flags)

fftwf_plan_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_dft_r2c(int rank,
                                                  @Const
                                                  IntBuffer n,
                                                  FloatBuffer in,
                                                  @Cast(value="fftwf_complex*")
                                                  FloatBuffer out,
                                                  @Cast(value="unsigned")
                                                  int flags)

fftwf_plan_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_dft_r2c(int rank,
                                                  @Const
                                                  int[] n,
                                                  float[] in,
                                                  @Cast(value="fftwf_complex*")
                                                  float[] out,
                                                  @Cast(value="unsigned")
                                                  int flags)

fftwf_plan_dft_r2c_1d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_1d(int n,
                                                     FloatPointer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_1d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_1d(int n,
                                                     FloatBuffer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_1d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_1d(int n,
                                                     float[] in,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_2d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_2d(int n0,
                                                     int n1,
                                                     FloatPointer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_2d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_2d(int n0,
                                                     int n1,
                                                     FloatBuffer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_2d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_2d(int n0,
                                                     int n1,
                                                     float[] in,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_3d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_3d(int n0,
                                                     int n1,
                                                     int n2,
                                                     FloatPointer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_3d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_3d(int n0,
                                                     int n1,
                                                     int n2,
                                                     FloatBuffer in,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_r2c_3d

public static fftw3.fftwf_plan fftwf_plan_dft_r2c_3d(int n0,
                                                     int n1,
                                                     int n2,
                                                     float[] in,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_many_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_many_dft_c2r(int rank,
                                                       @Const
                                                       IntPointer n,
                                                       int howmany,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatPointer in,
                                                       @Const
                                                       IntPointer inembed,
                                                       int istride,
                                                       int idist,
                                                       FloatPointer out,
                                                       @Const
                                                       IntPointer onembed,
                                                       int ostride,
                                                       int odist,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_many_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_many_dft_c2r(int rank,
                                                       @Const
                                                       IntBuffer n,
                                                       int howmany,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatBuffer in,
                                                       @Const
                                                       IntBuffer inembed,
                                                       int istride,
                                                       int idist,
                                                       FloatBuffer out,
                                                       @Const
                                                       IntBuffer onembed,
                                                       int ostride,
                                                       int odist,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_many_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_many_dft_c2r(int rank,
                                                       @Const
                                                       int[] n,
                                                       int howmany,
                                                       @Cast(value="fftwf_complex*")
                                                       float[] in,
                                                       @Const
                                                       int[] inembed,
                                                       int istride,
                                                       int idist,
                                                       float[] out,
                                                       @Const
                                                       int[] onembed,
                                                       int ostride,
                                                       int odist,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_dft_c2r(int rank,
                                                  @Const
                                                  IntPointer n,
                                                  @Cast(value="fftwf_complex*")
                                                  FloatPointer in,
                                                  FloatPointer out,
                                                  @Cast(value="unsigned")
                                                  int flags)

fftwf_plan_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_dft_c2r(int rank,
                                                  @Const
                                                  IntBuffer n,
                                                  @Cast(value="fftwf_complex*")
                                                  FloatBuffer in,
                                                  FloatBuffer out,
                                                  @Cast(value="unsigned")
                                                  int flags)

fftwf_plan_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_dft_c2r(int rank,
                                                  @Const
                                                  int[] n,
                                                  @Cast(value="fftwf_complex*")
                                                  float[] in,
                                                  float[] out,
                                                  @Cast(value="unsigned")
                                                  int flags)

fftwf_plan_dft_c2r_1d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_1d(int n,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer in,
                                                     FloatPointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_1d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_1d(int n,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer in,
                                                     FloatBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_1d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_1d(int n,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] in,
                                                     float[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_2d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_2d(int n0,
                                                     int n1,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer in,
                                                     FloatPointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_2d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_2d(int n0,
                                                     int n1,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer in,
                                                     FloatBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_2d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_2d(int n0,
                                                     int n1,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] in,
                                                     float[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_3d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_3d(int n0,
                                                     int n1,
                                                     int n2,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatPointer in,
                                                     FloatPointer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_3d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_3d(int n0,
                                                     int n1,
                                                     int n2,
                                                     @Cast(value="fftwf_complex*")
                                                     FloatBuffer in,
                                                     FloatBuffer out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_dft_c2r_3d

public static fftw3.fftwf_plan fftwf_plan_dft_c2r_3d(int n0,
                                                     int n1,
                                                     int n2,
                                                     @Cast(value="fftwf_complex*")
                                                     float[] in,
                                                     float[] out,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_guru_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru_dft_r2c(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       FloatPointer in,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatPointer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_guru_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru_dft_r2c(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       FloatBuffer in,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatBuffer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_guru_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru_dft_r2c(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       float[] in,
                                                       @Cast(value="fftwf_complex*")
                                                       float[] out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_guru_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru_dft_c2r(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatPointer in,
                                                       FloatPointer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_guru_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru_dft_c2r(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       @Cast(value="fftwf_complex*")
                                                       FloatBuffer in,
                                                       FloatBuffer out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_guru_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru_dft_c2r(int rank,
                                                       @Const
                                                       fftw3.fftw_iodim dims,
                                                       int howmany_rank,
                                                       @Const
                                                       fftw3.fftw_iodim howmany_dims,
                                                       @Cast(value="fftwf_complex*")
                                                       float[] in,
                                                       float[] out,
                                                       @Cast(value="unsigned")
                                                       int flags)

fftwf_plan_guru_split_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft_r2c(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim howmany_dims,
                                                             FloatPointer in,
                                                             FloatPointer ro,
                                                             FloatPointer io,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftwf_plan_guru_split_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft_r2c(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim howmany_dims,
                                                             FloatBuffer in,
                                                             FloatBuffer ro,
                                                             FloatBuffer io,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftwf_plan_guru_split_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft_r2c(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim howmany_dims,
                                                             float[] in,
                                                             float[] ro,
                                                             float[] io,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftwf_plan_guru_split_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft_c2r(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim howmany_dims,
                                                             FloatPointer ri,
                                                             FloatPointer ii,
                                                             FloatPointer out,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftwf_plan_guru_split_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft_c2r(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim howmany_dims,
                                                             FloatBuffer ri,
                                                             FloatBuffer ii,
                                                             FloatBuffer out,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftwf_plan_guru_split_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru_split_dft_c2r(int rank,
                                                             @Const
                                                             fftw3.fftw_iodim dims,
                                                             int howmany_rank,
                                                             @Const
                                                             fftw3.fftw_iodim howmany_dims,
                                                             float[] ri,
                                                             float[] ii,
                                                             float[] out,
                                                             @Cast(value="unsigned")
                                                             int flags)

fftwf_plan_guru64_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru64_dft_r2c(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         FloatPointer in,
                                                         @Cast(value="fftwf_complex*")
                                                         FloatPointer out,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru64_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru64_dft_r2c(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         FloatBuffer in,
                                                         @Cast(value="fftwf_complex*")
                                                         FloatBuffer out,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru64_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru64_dft_r2c(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         float[] in,
                                                         @Cast(value="fftwf_complex*")
                                                         float[] out,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru64_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru64_dft_c2r(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         @Cast(value="fftwf_complex*")
                                                         FloatPointer in,
                                                         FloatPointer out,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru64_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru64_dft_c2r(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         @Cast(value="fftwf_complex*")
                                                         FloatBuffer in,
                                                         FloatBuffer out,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru64_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru64_dft_c2r(int rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 dims,
                                                         int howmany_rank,
                                                         @Const
                                                         fftw3.fftw_iodim64 howmany_dims,
                                                         @Cast(value="fftwf_complex*")
                                                         float[] in,
                                                         float[] out,
                                                         @Cast(value="unsigned")
                                                         int flags)

fftwf_plan_guru64_split_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft_r2c(int rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 dims,
                                                               int howmany_rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 howmany_dims,
                                                               FloatPointer in,
                                                               FloatPointer ro,
                                                               FloatPointer io,
                                                               @Cast(value="unsigned")
                                                               int flags)

fftwf_plan_guru64_split_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft_r2c(int rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 dims,
                                                               int howmany_rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 howmany_dims,
                                                               FloatBuffer in,
                                                               FloatBuffer ro,
                                                               FloatBuffer io,
                                                               @Cast(value="unsigned")
                                                               int flags)

fftwf_plan_guru64_split_dft_r2c

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft_r2c(int rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 dims,
                                                               int howmany_rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 howmany_dims,
                                                               float[] in,
                                                               float[] ro,
                                                               float[] io,
                                                               @Cast(value="unsigned")
                                                               int flags)

fftwf_plan_guru64_split_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft_c2r(int rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 dims,
                                                               int howmany_rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 howmany_dims,
                                                               FloatPointer ri,
                                                               FloatPointer ii,
                                                               FloatPointer out,
                                                               @Cast(value="unsigned")
                                                               int flags)

fftwf_plan_guru64_split_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft_c2r(int rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 dims,
                                                               int howmany_rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 howmany_dims,
                                                               FloatBuffer ri,
                                                               FloatBuffer ii,
                                                               FloatBuffer out,
                                                               @Cast(value="unsigned")
                                                               int flags)

fftwf_plan_guru64_split_dft_c2r

public static fftw3.fftwf_plan fftwf_plan_guru64_split_dft_c2r(int rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 dims,
                                                               int howmany_rank,
                                                               @Const
                                                               fftw3.fftw_iodim64 howmany_dims,
                                                               float[] ri,
                                                               float[] ii,
                                                               float[] out,
                                                               @Cast(value="unsigned")
                                                               int flags)

fftwf_execute_dft_r2c

public static void fftwf_execute_dft_r2c(fftw3.fftwf_plan p,
                                         FloatPointer in,
                                         @Cast(value="fftwf_complex*")
                                         FloatPointer out)

fftwf_execute_dft_r2c

public static void fftwf_execute_dft_r2c(fftw3.fftwf_plan p,
                                         FloatBuffer in,
                                         @Cast(value="fftwf_complex*")
                                         FloatBuffer out)

fftwf_execute_dft_r2c

public static void fftwf_execute_dft_r2c(fftw3.fftwf_plan p,
                                         float[] in,
                                         @Cast(value="fftwf_complex*")
                                         float[] out)

fftwf_execute_dft_c2r

public static void fftwf_execute_dft_c2r(fftw3.fftwf_plan p,
                                         @Cast(value="fftwf_complex*")
                                         FloatPointer in,
                                         FloatPointer out)

fftwf_execute_dft_c2r

public static void fftwf_execute_dft_c2r(fftw3.fftwf_plan p,
                                         @Cast(value="fftwf_complex*")
                                         FloatBuffer in,
                                         FloatBuffer out)

fftwf_execute_dft_c2r

public static void fftwf_execute_dft_c2r(fftw3.fftwf_plan p,
                                         @Cast(value="fftwf_complex*")
                                         float[] in,
                                         float[] out)

fftwf_execute_split_dft_r2c

public static void fftwf_execute_split_dft_r2c(fftw3.fftwf_plan p,
                                               FloatPointer in,
                                               FloatPointer ro,
                                               FloatPointer io)

fftwf_execute_split_dft_r2c

public static void fftwf_execute_split_dft_r2c(fftw3.fftwf_plan p,
                                               FloatBuffer in,
                                               FloatBuffer ro,
                                               FloatBuffer io)

fftwf_execute_split_dft_r2c

public static void fftwf_execute_split_dft_r2c(fftw3.fftwf_plan p,
                                               float[] in,
                                               float[] ro,
                                               float[] io)

fftwf_execute_split_dft_c2r

public static void fftwf_execute_split_dft_c2r(fftw3.fftwf_plan p,
                                               FloatPointer ri,
                                               FloatPointer ii,
                                               FloatPointer out)

fftwf_execute_split_dft_c2r

public static void fftwf_execute_split_dft_c2r(fftw3.fftwf_plan p,
                                               FloatBuffer ri,
                                               FloatBuffer ii,
                                               FloatBuffer out)

fftwf_execute_split_dft_c2r

public static void fftwf_execute_split_dft_c2r(fftw3.fftwf_plan p,
                                               float[] ri,
                                               float[] ii,
                                               float[] out)

fftwf_plan_many_r2r

public static fftw3.fftwf_plan fftwf_plan_many_r2r(int rank,
                                                   @Const
                                                   IntPointer n,
                                                   int howmany,
                                                   FloatPointer in,
                                                   @Const
                                                   IntPointer inembed,
                                                   int istride,
                                                   int idist,
                                                   FloatPointer out,
                                                   @Const
                                                   IntPointer onembed,
                                                   int ostride,
                                                   int odist,
                                                   @Cast(value="const fftwf_r2r_kind*")
                                                   IntPointer kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_many_r2r

public static fftw3.fftwf_plan fftwf_plan_many_r2r(int rank,
                                                   @Const
                                                   IntBuffer n,
                                                   int howmany,
                                                   FloatBuffer in,
                                                   @Const
                                                   IntBuffer inembed,
                                                   int istride,
                                                   int idist,
                                                   FloatBuffer out,
                                                   @Const
                                                   IntBuffer onembed,
                                                   int ostride,
                                                   int odist,
                                                   @Cast(value="const fftwf_r2r_kind*")
                                                   IntBuffer kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_many_r2r

public static fftw3.fftwf_plan fftwf_plan_many_r2r(int rank,
                                                   @Const
                                                   int[] n,
                                                   int howmany,
                                                   float[] in,
                                                   @Const
                                                   int[] inembed,
                                                   int istride,
                                                   int idist,
                                                   float[] out,
                                                   @Const
                                                   int[] onembed,
                                                   int ostride,
                                                   int odist,
                                                   @Cast(value="const fftwf_r2r_kind*")
                                                   int[] kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_r2r

public static fftw3.fftwf_plan fftwf_plan_r2r(int rank,
                                              @Const
                                              IntPointer n,
                                              FloatPointer in,
                                              FloatPointer out,
                                              @Cast(value="const fftwf_r2r_kind*")
                                              IntPointer kind,
                                              @Cast(value="unsigned")
                                              int flags)

fftwf_plan_r2r

public static fftw3.fftwf_plan fftwf_plan_r2r(int rank,
                                              @Const
                                              IntBuffer n,
                                              FloatBuffer in,
                                              FloatBuffer out,
                                              @Cast(value="const fftwf_r2r_kind*")
                                              IntBuffer kind,
                                              @Cast(value="unsigned")
                                              int flags)

fftwf_plan_r2r

public static fftw3.fftwf_plan fftwf_plan_r2r(int rank,
                                              @Const
                                              int[] n,
                                              float[] in,
                                              float[] out,
                                              @Cast(value="const fftwf_r2r_kind*")
                                              int[] kind,
                                              @Cast(value="unsigned")
                                              int flags)

fftwf_plan_r2r_1d

public static fftw3.fftwf_plan fftwf_plan_r2r_1d(int n,
                                                 FloatPointer in,
                                                 FloatPointer out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_1d

public static fftw3.fftwf_plan fftwf_plan_r2r_1d(int n,
                                                 FloatBuffer in,
                                                 FloatBuffer out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_1d

public static fftw3.fftwf_plan fftwf_plan_r2r_1d(int n,
                                                 float[] in,
                                                 float[] out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_2d

public static fftw3.fftwf_plan fftwf_plan_r2r_2d(int n0,
                                                 int n1,
                                                 FloatPointer in,
                                                 FloatPointer out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind0,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind1,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_2d

public static fftw3.fftwf_plan fftwf_plan_r2r_2d(int n0,
                                                 int n1,
                                                 FloatBuffer in,
                                                 FloatBuffer out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind0,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind1,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_2d

public static fftw3.fftwf_plan fftwf_plan_r2r_2d(int n0,
                                                 int n1,
                                                 float[] in,
                                                 float[] out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind0,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind1,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_3d

public static fftw3.fftwf_plan fftwf_plan_r2r_3d(int n0,
                                                 int n1,
                                                 int n2,
                                                 FloatPointer in,
                                                 FloatPointer out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind0,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind1,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind2,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_3d

public static fftw3.fftwf_plan fftwf_plan_r2r_3d(int n0,
                                                 int n1,
                                                 int n2,
                                                 FloatBuffer in,
                                                 FloatBuffer out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind0,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind1,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind2,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_r2r_3d

public static fftw3.fftwf_plan fftwf_plan_r2r_3d(int n0,
                                                 int n1,
                                                 int n2,
                                                 float[] in,
                                                 float[] out,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind0,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind1,
                                                 @Cast(value="fftwf_r2r_kind")
                                                 int kind2,
                                                 @Cast(value="unsigned")
                                                 int flags)

fftwf_plan_guru_r2r

public static fftw3.fftwf_plan fftwf_plan_guru_r2r(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim howmany_dims,
                                                   FloatPointer in,
                                                   FloatPointer out,
                                                   @Cast(value="const fftwf_r2r_kind*")
                                                   IntPointer kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_guru_r2r

public static fftw3.fftwf_plan fftwf_plan_guru_r2r(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim howmany_dims,
                                                   FloatBuffer in,
                                                   FloatBuffer out,
                                                   @Cast(value="const fftwf_r2r_kind*")
                                                   IntBuffer kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_guru_r2r

public static fftw3.fftwf_plan fftwf_plan_guru_r2r(int rank,
                                                   @Const
                                                   fftw3.fftw_iodim dims,
                                                   int howmany_rank,
                                                   @Const
                                                   fftw3.fftw_iodim howmany_dims,
                                                   float[] in,
                                                   float[] out,
                                                   @Cast(value="const fftwf_r2r_kind*")
                                                   int[] kind,
                                                   @Cast(value="unsigned")
                                                   int flags)

fftwf_plan_guru64_r2r

public static fftw3.fftwf_plan fftwf_plan_guru64_r2r(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 howmany_dims,
                                                     FloatPointer in,
                                                     FloatPointer out,
                                                     @Cast(value="const fftwf_r2r_kind*")
                                                     IntPointer kind,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_guru64_r2r

public static fftw3.fftwf_plan fftwf_plan_guru64_r2r(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 howmany_dims,
                                                     FloatBuffer in,
                                                     FloatBuffer out,
                                                     @Cast(value="const fftwf_r2r_kind*")
                                                     IntBuffer kind,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_plan_guru64_r2r

public static fftw3.fftwf_plan fftwf_plan_guru64_r2r(int rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 dims,
                                                     int howmany_rank,
                                                     @Const
                                                     fftw3.fftw_iodim64 howmany_dims,
                                                     float[] in,
                                                     float[] out,
                                                     @Cast(value="const fftwf_r2r_kind*")
                                                     int[] kind,
                                                     @Cast(value="unsigned")
                                                     int flags)

fftwf_execute_r2r

public static void fftwf_execute_r2r(fftw3.fftwf_plan p,
                                     FloatPointer in,
                                     FloatPointer out)

fftwf_execute_r2r

public static void fftwf_execute_r2r(fftw3.fftwf_plan p,
                                     FloatBuffer in,
                                     FloatBuffer out)

fftwf_execute_r2r

public static void fftwf_execute_r2r(fftw3.fftwf_plan p,
                                     float[] in,
                                     float[] out)

fftwf_destroy_plan

public static void fftwf_destroy_plan(fftw3.fftwf_plan p)

fftwf_forget_wisdom

public static void fftwf_forget_wisdom()

fftwf_cleanup
```
public static void fftwf_cleanup()
```

fftwf_set_timelimit

public static void fftwf_set_timelimit(double t)

fftwf_plan_with_nthreads

public static void fftwf_plan_with_nthreads(int nthreads)

fftwf_planner_nthreads

public static int fftwf_planner_nthreads()

fftwf_init_threads

public static int fftwf_init_threads()

fftwf_cleanup_threads

public static void fftwf_cleanup_threads()

fftwf_threads_set_callback

public static void fftwf_threads_set_callback(fftw3.Parallel_loop_Work_BytePointer_BytePointer_long_int_Pointer parallel_loop,
                                              Pointer data)

fftwf_threads_set_callback

public static void fftwf_threads_set_callback(fftw3.Parallel_loop_Work_ByteBuffer_ByteBuffer_long_int_Pointer parallel_loop,
                                              Pointer data)

fftwf_threads_set_callback

public static void fftwf_threads_set_callback(fftw3.Parallel_loop_Work_byte___byte___long_int_Pointer parallel_loop,
                                              Pointer data)

fftwf_make_planner_thread_safe

public static void fftwf_make_planner_thread_safe()

fftwf_export_wisdom_to_filename

public static int fftwf_export_wisdom_to_filename(@Cast(value="const char*")
                                                  BytePointer filename)

fftwf_export_wisdom_to_filename

public static int fftwf_export_wisdom_to_filename(String filename)

fftwf_export_wisdom_to_file

public static void fftwf_export_wisdom_to_file(@Cast(value="FILE*")
                                               Pointer output_file)

fftwf_export_wisdom_to_string

@Cast(value="char*")
public static BytePointer fftwf_export_wisdom_to_string()

fftwf_export_wisdom

public static void fftwf_export_wisdom(@Cast(value="fftwf_write_char_func")
                                       fftw3.fftw_write_char_func_do_not_use_me write_char,
                                       Pointer data)

fftwf_import_system_wisdom

public static int fftwf_import_system_wisdom()

fftwf_import_wisdom_from_filename

public static int fftwf_import_wisdom_from_filename(@Cast(value="const char*")
                                                    BytePointer filename)

fftwf_import_wisdom_from_filename

public static int fftwf_import_wisdom_from_filename(String filename)

fftwf_import_wisdom_from_file

public static int fftwf_import_wisdom_from_file(@Cast(value="FILE*")
                                                Pointer input_file)

fftwf_import_wisdom_from_string

public static int fftwf_import_wisdom_from_string(@Cast(value="const char*")
                                                  BytePointer input_string)

fftwf_import_wisdom_from_string

public static int fftwf_import_wisdom_from_string(String input_string)

fftwf_import_wisdom

public static int fftwf_import_wisdom(@Cast(value="fftwf_read_char_func")
                                      fftw3.fftw_read_char_func_do_not_use_me read_char,
                                      Pointer data)

fftwf_fprint_plan

public static void fftwf_fprint_plan(fftw3.fftwf_plan p,
                                     @Cast(value="FILE*")
                                     Pointer output_file)

fftwf_print_plan

public static void fftwf_print_plan(fftw3.fftwf_plan p)

fftwf_sprint_plan

@Cast(value="char*")
public static BytePointer fftwf_sprint_plan(fftw3.fftwf_plan p)

fftwf_malloc

public static Pointer fftwf_malloc(@Cast(value="size_t")
                                   long n)

fftwf_alloc_real

public static FloatPointer fftwf_alloc_real(@Cast(value="size_t")
                                            long n)

fftwf_alloc_complex

@Cast(value="fftwf_complex*")
public static FloatPointer fftwf_alloc_complex(@Cast(value="size_t")
                                                                             long n)

fftwf_free

public static void fftwf_free(Pointer p)

fftwf_flops

public static void fftwf_flops(fftw3.fftwf_plan p,
                               DoublePointer add,
                               DoublePointer mul,
                               DoublePointer fmas)

fftwf_flops

public static void fftwf_flops(fftw3.fftwf_plan p,
                               DoubleBuffer add,
                               DoubleBuffer mul,
                               DoubleBuffer fmas)

fftwf_flops

public static void fftwf_flops(fftw3.fftwf_plan p,
                               double[] add,
                               double[] mul,
                               double[] fmas)

fftwf_estimate_cost

public static double fftwf_estimate_cost(fftw3.fftwf_plan p)

fftwf_cost

public static double fftwf_cost(fftw3.fftwf_plan p)

fftwf_alignment_of

public static int fftwf_alignment_of(FloatPointer p)

fftwf_alignment_of

public static int fftwf_alignment_of(FloatBuffer p)

fftwf_alignment_of

public static int fftwf_alignment_of(float[] p)

fftwf_version

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char")
public static byte fftwf_version(int i)

fftwf_version

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char*")
public static BytePointer fftwf_version()

fftwf_cc

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char")
public static byte fftwf_cc(int i)

fftwf_cc

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char*")
public static BytePointer fftwf_cc()

fftwf_codelet_optim

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char")
public static byte fftwf_codelet_optim(int i)

fftwf_codelet_optim

@MemberGetter
 @Platform(not="windows")
 @Cast(value="const char*")
public static BytePointer fftwf_codelet_optim()

Class fftw3

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.fftw.presets.fftw3

Methods inherited from class java.lang.Object

Field Detail

FFTW_R2HC

FFTW_HC2R

FFTW_DHT

FFTW_REDFT00

FFTW_REDFT01

FFTW_REDFT10

FFTW_REDFT11

FFTW_RODFT00

FFTW_RODFT01

FFTW_RODFT10

FFTW_RODFT11

FFTW_FORWARD

FFTW_BACKWARD

FFTW_NO_TIMELIMIT

FFTW_MEASURE

FFTW_DESTROY_INPUT

FFTW_UNALIGNED

FFTW_CONSERVE_MEMORY

FFTW_EXHAUSTIVE

FFTW_PRESERVE_INPUT

FFTW_PATIENT

FFTW_ESTIMATE

FFTW_WISDOM_ONLY

FFTW_ESTIMATE_PATIENT

FFTW_BELIEVE_PCOST

FFTW_NO_DFT_R2HC

FFTW_NO_NONTHREADED

FFTW_NO_BUFFERING

FFTW_NO_INDIRECT_OP

FFTW_ALLOW_LARGE_GENERIC

FFTW_NO_RANK_SPLITS

FFTW_NO_VRANK_SPLITS

FFTW_NO_VRECURSE

FFTW_NO_SIMD

FFTW_NO_SLOW

FFTW_NO_FIXED_RADIX_LARGE_N

FFTW_ALLOW_PRUNING

Constructor Detail

fftw3

Method Detail

fftw_execute

fftw_plan_dft

fftw_plan_dft

fftw_plan_dft

fftw_plan_dft_1d

fftw_plan_dft_1d

fftw_plan_dft_1d

fftw_plan_dft_2d

fftw_plan_dft_2d

fftw_plan_dft_2d

fftw_plan_dft_3d

fftw_plan_dft_3d

fftw_plan_dft_3d

fftw_plan_many_dft

fftw_plan_many_dft

fftw_plan_many_dft

fftw_plan_guru_dft

fftw_plan_guru_dft

fftw_plan_guru_dft

fftw_plan_guru_split_dft

fftw_plan_guru_split_dft

fftw_plan_guru_split_dft

fftw_plan_guru64_dft

fftw_plan_guru64_dft

fftw_plan_guru64_dft

fftw_plan_guru64_split_dft

fftw_plan_guru64_split_dft

fftw_plan_guru64_split_dft

fftw_execute_dft

fftw_execute_dft

fftw_execute_dft

fftw_execute_split_dft