NFFT  3.5.3alpha
Data Structures | Macros | Typedefs | Functions | Variables
nfft3.h File Reference

Header file for the nfft3 library. More...

#include <fftw3.h>
Include dependency graph for nfft3.h:

Go to the source code of this file.

Data Structures

struct  nfftf_mv_plan_complex
 
struct  nfftf_mv_plan_double
 
struct  nfftl_mv_plan_double
 
struct  nfctf_plan
 data structure for an NFCT (nonequispaced fast cosine transform) plan with float precision More...
 
struct  nfstf_plan
 data structure for an NFST (nonequispaced fast sine transform) plan with float precision More...
 
struct  nnfftf_plan
 data structure for an NNFFT (nonequispaced in time and frequency fast Fourier transform) plan with float precision More...
 
struct  nsfftf_plan
 data structure for an NSFFT (nonequispaced sparse fast Fourier transform) plan with float precision More...
 
struct  mrif_inh_2d1d_plan
 
struct  mrif_inh_3d_plan
 
struct  mril_inh_3d_plan
 
struct  nfsftf_plan
 data structure for an NFSFT (nonequispaced fast spherical Fourier transform) plan with float precision More...
 
struct  nfsoftf_plan_
 
struct  solverf_plan_complex
 data structure for an inverse NFFT plan with float precision More...
 
struct  solverf_plan_double
 data structure for an inverse NFFT plan with float precision More...
 
struct  solverl_plan_double
 data structure for an inverse NFFT plan with long double precision More...
 

Macros

#define NFFT_CONCAT(prefix, name)   prefix ## name
 
#define NFFT_EXTERN   extern
 
#define MACRO_MV_PLAN(RC)
 Adjoint transform. More...
 
#define NFFT_MANGLE_DOUBLE(name)   NFFT_CONCAT(nfft_, name)
 
#define NFFT_MANGLE_FLOAT(name)   NFFT_CONCAT(nfftf_, name)
 
#define NFFT_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(nfftl_, name)
 
#define NFFT_DEFINE_MALLOC_API(X)
 
#define NFFT_DEFINE_API(X, Y, R, C)
 
#define PRE_PHI_HUT   (1U<<0)
 
#define FG_PSI   (1U<<1)
 
#define PRE_LIN_PSI   (1U<<2)
 
#define PRE_FG_PSI   (1U<<3)
 
#define PRE_PSI   (1U<<4)
 
#define PRE_FULL_PSI   (1U<<5)
 
#define MALLOC_X   (1U<<6)
 
#define MALLOC_F_HAT   (1U<<7)
 
#define MALLOC_F   (1U<<8)
 
#define FFT_OUT_OF_PLACE   (1U<<9)
 
#define FFTW_INIT   (1U<<10)
 
#define NFFT_SORT_NODES   (1U<<11)
 
#define NFFT_OMP_BLOCKWISE_ADJOINT   (1U<<12)
 
#define PRE_ONE_PSI   (PRE_LIN_PSI| PRE_FG_PSI| PRE_PSI| PRE_FULL_PSI)
 
#define NFCT_MANGLE_DOUBLE(name)   NFFT_CONCAT(nfct_, name)
 
#define NFCT_MANGLE_FLOAT(name)   NFFT_CONCAT(nfctf_, name)
 
#define NFCT_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(nfctl_, name)
 
#define NFCT_DEFINE_API(X, Y, R, C)
 
#define NFST_MANGLE_DOUBLE(name)   NFFT_CONCAT(nfst_, name)
 
#define NFST_MANGLE_FLOAT(name)   NFFT_CONCAT(nfstf_, name)
 
#define NFST_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(nfstl_, name)
 
#define NFST_DEFINE_API(X, Y, R, C)
 
#define NNFFT_MANGLE_DOUBLE(name)   NFFT_CONCAT(nnfft_, name)
 
#define NNFFT_MANGLE_FLOAT(name)   NFFT_CONCAT(nnfftf_, name)
 
#define NNFFT_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(nnfftl_, name)
 
#define NNFFT_DEFINE_API(X, Y, Z, R, C)
 
#define MALLOC_V   (1U<< 11)
 
#define NSFFT_MANGLE_DOUBLE(name)   NFFT_CONCAT(nsfft_, name)
 
#define NSFFT_MANGLE_FLOAT(name)   NFFT_CONCAT(nsfftf_, name)
 
#define NSFFT_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(nsfftl_, name)
 
#define NSFFT_DEFINE_API(X, Y, Z, R, C)
 
#define NSDFT   (1U<< 12)
 
#define MRI_MANGLE_DOUBLE(name)   NFFT_CONCAT(mri_, name)
 
#define MRI_MANGLE_FLOAT(name)   NFFT_CONCAT(mrif_, name)
 
#define MRI_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(mril_, name)
 
#define MRI_DEFINE_API(X, Z, R, C)
 
#define NFSFT_MANGLE_DOUBLE(name)   NFFT_CONCAT(nfsft_, name)
 
#define NFSFT_MANGLE_FLOAT(name)   NFFT_CONCAT(nfsftf_, name)
 
#define NFSFT_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(nfsftl_, name)
 
#define NFSFT_DEFINE_API(X, Z, R, C)
 
#define NFSFT_NORMALIZED   (1U << 0)
 
#define NFSFT_USE_NDFT   (1U << 1)
 
#define NFSFT_USE_DPT   (1U << 2)
 
#define NFSFT_MALLOC_X   (1U << 3)
 
#define NFSFT_MALLOC_F_HAT   (1U << 5)
 
#define NFSFT_MALLOC_F   (1U << 6)
 
#define NFSFT_PRESERVE_F_HAT   (1U << 7)
 
#define NFSFT_PRESERVE_X   (1U << 8)
 
#define NFSFT_PRESERVE_F   (1U << 9)
 
#define NFSFT_DESTROY_F_HAT   (1U << 10)
 
#define NFSFT_DESTROY_X   (1U << 11)
 
#define NFSFT_DESTROY_F   (1U << 12)
 
#define NFSFT_EQUISPACED   (1U << 17)
 
#define NFSFT_NO_DIRECT_ALGORITHM   (1U << 13)
 
#define NFSFT_NO_FAST_ALGORITHM   (1U << 14)
 
#define NFSFT_ZERO_F_HAT   (1U << 16)
 
#define NFSFT_INDEX(k, n, plan)   ((2*(plan)->N+2)*((plan)->N-n+1)+(plan)->N+k+1)
 
#define NFSFT_F_HAT_SIZE(N)   ((2*N+2)*(2*N+2))
 
#define FPT_MANGLE_DOUBLE(name)   NFFT_CONCAT(fpt_, name)
 
#define FPT_MANGLE_FLOAT(name)   NFFT_CONCAT(fptf_, name)
 
#define FPT_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(fptl_, name)
 
#define FPT_DEFINE_API(X, Y, R, C)
 
#define FPT_NO_STABILIZATION   (1U << 0)
 If set, no stabilization will be used.
 
#define FPT_NO_FAST_ALGORITHM   (1U << 2)
 If set, TODO complete comment.
 
#define FPT_NO_DIRECT_ALGORITHM   (1U << 3)
 If set, TODO complete comment.
 
#define FPT_PERSISTENT_DATA   (1U << 4)
 If set, TODO complete comment.
 
#define FPT_NO_INIT_FPT_DATA   (1U << 7)
 
#define FPT_FUNCTION_VALUES   (1U << 5)
 If set, the output are function values at Chebyshev nodes rather than Chebyshev coefficients.
 
#define FPT_AL_SYMMETRY   (1U << 6)
 If set, TODO complete comment.
 
#define NFSOFT_MANGLE_DOUBLE(name)   NFFT_CONCAT(nfsoft_, name)
 
#define NFSOFT_MANGLE_FLOAT(name)   NFFT_CONCAT(nfsoftf_, name)
 
#define NFSOFT_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(nfsoftl_, name)
 
#define NFSOFT_DEFINE_API(X, Y, Z, R, C)
 
#define NFSOFT_NORMALIZED   (1U << 0)
 
#define NFSOFT_USE_NDFT   (1U << 1)
 
#define NFSOFT_USE_DPT   (1U << 2)
 
#define NFSOFT_MALLOC_X   (1U << 3)
 
#define NFSOFT_REPRESENT   (1U << 4)
 
#define NFSOFT_MALLOC_F_HAT   (1U << 5)
 
#define NFSOFT_MALLOC_F   (1U << 6)
 
#define NFSOFT_PRESERVE_F_HAT   (1U << 7)
 
#define NFSOFT_PRESERVE_X   (1U << 8)
 
#define NFSOFT_PRESERVE_F   (1U << 9)
 
#define NFSOFT_DESTROY_F_HAT   (1U << 10)
 
#define NFSOFT_DESTROY_X   (1U << 11)
 
#define NFSOFT_DESTROY_F   (1U << 12)
 
#define NFSOFT_NO_STABILIZATION   (1U << 13)
 
#define NFSOFT_CHOOSE_DPT   (1U << 14)
 
#define NFSOFT_SOFT   (1U << 15)
 
#define NFSOFT_ZERO_F_HAT   (1U << 16)
 
#define NFSOFT_INDEX(m, n, l, B)   (((l)+((B)+1))+(2*(B)+2)*(((n)+((B)+1))+(2*(B)+2)*((m)+((B)+1))))
 
#define NFSOFT_F_HAT_SIZE(B)   (((B)+1)*(4*((B)+1)*((B)+1)-1)/3)
 
#define SOLVER_MANGLE_DOUBLE(name)   NFFT_CONCAT(solver_, name)
 
#define SOLVER_MANGLE_FLOAT(name)   NFFT_CONCAT(solverf_, name)
 
#define SOLVER_MANGLE_LONG_DOUBLE(name)   NFFT_CONCAT(solverl_, name)
 
#define SOLVER_DEFINE_API(X, Y, R, C)
 
#define LANDWEBER   (1U<< 0)
 
#define STEEPEST_DESCENT   (1U<< 1)
 
#define CGNR   (1U<< 2)
 
#define CGNE   (1U<< 3)
 
#define NORMS_FOR_LANDWEBER   (1U<< 4)
 
#define PRECOMPUTE_WEIGHT   (1U<< 5)
 
#define PRECOMPUTE_DAMP   (1U<< 6)
 
#define NFFT_DEFINE_UTIL_API(Y, R, C)
 

Typedefs

typedef ptrdiff_t NFFT_INT
 
typedef void *(* nfftf_malloc_type_function) (size_t n)
 
typedef void(* nfftf_free_type_function) (void *p)
 
typedef void(* nfftf_die_type_function) (const char *errString)
 
typedef void *(* nfftl_malloc_type_function) (size_t n)
 
typedef void(* nfftl_free_type_function) (void *p)
 
typedef void(* nfftl_die_type_function) (const char *errString)
 
typedef struct fptf_set_s_ * fptf_set
 A set of precomputed data for a set of DPT transforms of equal maximum length.
 
typedef struct nfsoftf_plan_ nfsoftf_plan
 

Functions

void * nfftf_malloc (size_t n)
 
void nfftf_free (void *p)
 
void nfftf_die (const char *s)
 
 NNNNNNNNNNNNNFFT_DEFINE_MALLOC_API (NFFT_MANGLE_DOUBLE) extern void *nfftl_malloc(size_t n)
 
void nfftl_free (void *p)
 
void nfftl_die (const char *s)
 
struct __attribute__ ((__packed__))
 data structure for an NFFT (nonequispaced fast Fourier transform) plan with float precision More...
 
void nfftf_trafo_direct (const nfftf_plan *ths)
 
void nfftf_adjoint_direct (const nfftf_plan *ths)
 
void nfftf_trafo (nfftf_plan *ths)
 
void nfftf_trafo_1d (nfftf_plan *ths)
 
void nfftf_trafo_2d (nfftf_plan *ths)
 
void nfftf_trafo_3d (nfftf_plan *ths)
 
void nfftf_adjoint (nfftf_plan *ths)
 
void nfftf_adjoint_1d (nfftf_plan *ths)
 
void nfftf_adjoint_2d (nfftf_plan *ths)
 
void nfftf_adjoint_3d (nfftf_plan *ths)
 
void nfftf_init_1d (nfftf_plan *ths, int N1, int M)
 
void nfftf_init_2d (nfftf_plan *ths, int N1, int N2, int M)
 
void nfftf_init_3d (nfftf_plan *ths, int N1, int N2, int N3, int M)
 
void nfftf_init (nfftf_plan *ths, int d, int *N, int M)
 
void nfftf_init_guru (nfftf_plan *ths, int d, int *N, int M, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfftf_init_lin (nfftf_plan *ths, int d, int *N, int M, int *n, int m, int K, unsigned flags, unsigned fftw_flags)
 
void nfftf_precompute_one_psi (nfftf_plan *ths)
 
void nfftf_precompute_psi (nfftf_plan *ths)
 
void nfftf_precompute_full_psi (nfftf_plan *ths)
 
void nfftf_precompute_fg_psi (nfftf_plan *ths)
 
void nfftf_precompute_lin_psi (nfftf_plan *ths)
 
const char * nfftf_check (nfftf_plan *ths)
 
void nfftf_finalize (nfftf_plan *ths)
 
 NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFT_DEFINE_API (NFFT_MANGLE_DOUBLE, FFTW_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 
void nfftl_trafo_direct (const nfftl_plan *ths)
 
void nfftl_adjoint_direct (const nfftl_plan *ths)
 
void nfftl_trafo (nfftl_plan *ths)
 
void nfftl_trafo_1d (nfftl_plan *ths)
 
void nfftl_trafo_2d (nfftl_plan *ths)
 
void nfftl_trafo_3d (nfftl_plan *ths)
 
void nfftl_adjoint (nfftl_plan *ths)
 
void nfftl_adjoint_1d (nfftl_plan *ths)
 
void nfftl_adjoint_2d (nfftl_plan *ths)
 
void nfftl_adjoint_3d (nfftl_plan *ths)
 
void nfftl_init_1d (nfftl_plan *ths, int N1, int M)
 
void nfftl_init_2d (nfftl_plan *ths, int N1, int N2, int M)
 
void nfftl_init_3d (nfftl_plan *ths, int N1, int N2, int N3, int M)
 
void nfftl_init (nfftl_plan *ths, int d, int *N, int M)
 
void nfftl_init_guru (nfftl_plan *ths, int d, int *N, int M, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfftl_init_lin (nfftl_plan *ths, int d, int *N, int M, int *n, int m, int K, unsigned flags, unsigned fftw_flags)
 
void nfftl_precompute_one_psi (nfftl_plan *ths)
 
void nfftl_precompute_psi (nfftl_plan *ths)
 
void nfftl_precompute_full_psi (nfftl_plan *ths)
 
void nfftl_precompute_fg_psi (nfftl_plan *ths)
 
void nfftl_precompute_lin_psi (nfftl_plan *ths)
 
const char * nfftl_check (nfftl_plan *ths)
 
void nfftl_finalize (nfftl_plan *ths)
 
void nfctf_init_1d (nfctf_plan *ths_plan, int N0, int M_total)
 
void nfctf_init_2d (nfctf_plan *ths_plan, int N0, int N1, int M_total)
 
void nfctf_init_3d (nfctf_plan *ths_plan, int N0, int N1, int N2, int M_total)
 
void nfctf_init (nfctf_plan *ths_plan, int d, int *N, int M_total)
 
void nfctf_init_guru (nfctf_plan *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfctf_precompute_one_psi (nfctf_plan *ths)
 
void nfctf_precompute_psi (nfctf_plan *ths)
 
void nfctf_precompute_full_psi (nfctf_plan *ths)
 
void nfctf_precompute_fg_psi (nfctf_plan *ths)
 
void nfctf_precompute_lin_psi (nfctf_plan *ths)
 
void nfctf_trafo (nfctf_plan *ths_plan)
 
void nfctf_trafo_direct (const nfctf_plan *ths_plan)
 
void nfctf_adjoint (nfctf_plan *ths_plan)
 
void nfctf_adjoint_direct (const nfctf_plan *ths_plan)
 
const char * nfctf_check (nfctf_plan *ths)
 
void nfctf_finalize (nfctf_plan *ths_plan)
 
 NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFCT_DEFINE_API (NFCT_MANGLE_DOUBLE, FFTW_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 data structure for an NFCT (nonequispaced fast cosine transform) plan with long double precision
 
void nfctl_init_1d (nfctl_plan *ths_plan, int N0, int M_total)
 
void nfctl_init_2d (nfctl_plan *ths_plan, int N0, int N1, int M_total)
 
void nfctl_init_3d (nfctl_plan *ths_plan, int N0, int N1, int N2, int M_total)
 
void nfctl_init (nfctl_plan *ths_plan, int d, int *N, int M_total)
 
void nfctl_init_guru (nfctl_plan *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfctl_precompute_one_psi (nfctl_plan *ths)
 
void nfctl_precompute_psi (nfctl_plan *ths)
 
void nfctl_precompute_full_psi (nfctl_plan *ths)
 
void nfctl_precompute_fg_psi (nfctl_plan *ths)
 
void nfctl_precompute_lin_psi (nfctl_plan *ths)
 
void nfctl_trafo (nfctl_plan *ths_plan)
 
void nfctl_trafo_direct (const nfctl_plan *ths_plan)
 
void nfctl_adjoint (nfctl_plan *ths_plan)
 
void nfctl_adjoint_direct (const nfctl_plan *ths_plan)
 
const char * nfctl_check (nfctl_plan *ths)
 
void nfctl_finalize (nfctl_plan *ths_plan)
 
void nfstf_init_1d (nfstf_plan *ths_plan, int N0, int M_total)
 
void nfstf_init_2d (nfstf_plan *ths_plan, int N0, int N1, int M_total)
 
void nfstf_init_3d (nfstf_plan *ths_plan, int N0, int N1, int N2, int M_total)
 
void nfstf_init (nfstf_plan *ths_plan, int d, int *N, int M_total)
 
void nfstf_init_guru (nfstf_plan *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfstf_precompute_one_psi (nfstf_plan *ths)
 
void nfstf_precompute_psi (nfstf_plan *ths)
 
void nfstf_precompute_full_psi (nfstf_plan *ths)
 
void nfstf_precompute_fg_psi (nfstf_plan *ths)
 
void nfstf_precompute_lin_psi (nfstf_plan *ths)
 
void nfstf_trafo (nfstf_plan *ths_plan)
 
void nfstf_trafo_direct (const nfstf_plan *ths_plan)
 
void nfstf_adjoint (nfstf_plan *ths_plan)
 
void nfstf_adjoint_direct (const nfstf_plan *ths_plan)
 
const char * nfstf_check (nfstf_plan *ths)
 
void nfstf_finalize (nfstf_plan *ths_plan)
 
 NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFST_DEFINE_API (NFST_MANGLE_DOUBLE, FFTW_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 data structure for an NFST (nonequispaced fast sine transform) plan with long double precision
 
void nfstl_init_1d (nfstl_plan *ths_plan, int N0, int M_total)
 
void nfstl_init_2d (nfstl_plan *ths_plan, int N0, int N1, int M_total)
 
void nfstl_init_3d (nfstl_plan *ths_plan, int N0, int N1, int N2, int M_total)
 
void nfstl_init (nfstl_plan *ths_plan, int d, int *N, int M_total)
 
void nfstl_init_guru (nfstl_plan *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfstl_precompute_one_psi (nfstl_plan *ths)
 
void nfstl_precompute_psi (nfstl_plan *ths)
 
void nfstl_precompute_full_psi (nfstl_plan *ths)
 
void nfstl_precompute_fg_psi (nfstl_plan *ths)
 
void nfstl_precompute_lin_psi (nfstl_plan *ths)
 
void nfstl_trafo (nfstl_plan *ths_plan)
 
void nfstl_trafo_direct (const nfstl_plan *ths_plan)
 
void nfstl_adjoint (nfstl_plan *ths_plan)
 
void nfstl_adjoint_direct (const nfstl_plan *ths_plan)
 
const char * nfstl_check (nfstl_plan *ths)
 
void nfstl_finalize (nfstl_plan *ths_plan)
 
void nnfftf_init (nnfftf_plan *ths_plan, int d, int N_total, int M_total, int *N)
 
void nnfftf_init_1d (nnfftf_plan *ths_plan, int N, int M_total)
 
void nnfftf_init_guru (nnfftf_plan *ths_plan, int d, int N_total, int M_total, int *N, int *N1, int m, unsigned nnfft_flags)
 
void nnfftf_trafo_direct (nnfftf_plan *ths_plan)
 
void nnfftf_adjoint_direct (nnfftf_plan *ths_plan)
 
void nnfftf_trafo (nnfftf_plan *ths_plan)
 
void nnfftf_adjoint (nnfftf_plan *ths_plan)
 
void nnfftf_precompute_lin_psi (nnfftf_plan *ths_plan)
 
void nnfftf_precompute_psi (nnfftf_plan *ths_plan)
 
void nnfftf_precompute_full_psi (nnfftf_plan *ths_plan)
 
void nnfftf_precompute_phi_hut (nnfftf_plan *ths_plan)
 
void nnfftf_precompute_one_psi (nnfftf_plan *ths)
 
void nnfftf_finalize (nnfftf_plan *ths_plan)
 
 NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFT_DEFINE_API (NNFFT_MANGLE_DOUBLE, FFTW_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 data structure for an NNFFT (nonequispaced in time and frequency fast Fourier transform) plan with long double precision
 
void nnfftl_init (nnfftl_plan *ths_plan, int d, int N_total, int M_total, int *N)
 
void nnfftl_init_1d (nnfftl_plan *ths_plan, int N, int M_total)
 
void nnfftl_init_guru (nnfftl_plan *ths_plan, int d, int N_total, int M_total, int *N, int *N1, int m, unsigned nnfft_flags)
 
void nnfftl_trafo_direct (nnfftl_plan *ths_plan)
 
void nnfftl_adjoint_direct (nnfftl_plan *ths_plan)
 
void nnfftl_trafo (nnfftl_plan *ths_plan)
 
void nnfftl_adjoint (nnfftl_plan *ths_plan)
 
void nnfftl_precompute_lin_psi (nnfftl_plan *ths_plan)
 
void nnfftl_precompute_psi (nnfftl_plan *ths_plan)
 
void nnfftl_precompute_full_psi (nnfftl_plan *ths_plan)
 
void nnfftl_precompute_phi_hut (nnfftl_plan *ths_plan)
 
void nnfftl_precompute_one_psi (nnfftl_plan *ths)
 
void nnfftl_finalize (nnfftl_plan *ths_plan)
 
void nsfftf_trafo_direct (nsfftf_plan *ths)
 
void nsfftf_adjoint_direct (nsfftf_plan *ths)
 
void nsfftf_trafo (nsfftf_plan *ths)
 
void nsfftf_adjoint (nsfftf_plan *ths)
 
void nsfftf_cp (nsfftf_plan *ths, nfftf_plan *ths_nfft)
 
void nsfftf_init_random_nodes_coeffs (nsfftf_plan *ths)
 
void nsfftf_init (nsfftf_plan *ths, int d, int J, int M, int m, unsigned flags)
 
void nsfftf_finalize (nsfftf_plan *ths)
 
 NNNNNNNNNNNNNNNNNNNNNNNSFFT_DEFINE_API (NSFFT_MANGLE_DOUBLE, FFTW_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 data structure for an NSFFT (nonequispaced sparse fast Fourier transform) plan with long double precision
 
void nsfftl_trafo_direct (nsfftl_plan *ths)
 
void nsfftl_adjoint_direct (nsfftl_plan *ths)
 
void nsfftl_trafo (nsfftl_plan *ths)
 
void nsfftl_adjoint (nsfftl_plan *ths)
 
void nsfftl_cp (nsfftl_plan *ths, nfftl_plan *ths_nfft)
 
void nsfftl_init_random_nodes_coeffs (nsfftl_plan *ths)
 
void nsfftl_init (nsfftl_plan *ths, int d, int J, int M, int m, unsigned flags)
 
void nsfftl_finalize (nsfftl_plan *ths)
 
void mrif_inh_2d1d_trafo (mrif_inh_2d1d_plan *ths)
 
void mrif_inh_2d1d_adjoint (mrif_inh_2d1d_plan *ths)
 
void mrif_inh_2d1d_init_guru (mrif_inh_2d1d_plan *ths, int *N, int M, int *n, int m, float sigma, unsigned nfft_flags, unsigned fftw_flags)
 
void mrif_inh_2d1d_finalize (mrif_inh_2d1d_plan *ths)
 
void mrif_inh_3d_trafo (mrif_inh_3d_plan *ths)
 
void mrif_inh_3d_adjoint (mrif_inh_3d_plan *ths)
 
void mrif_inh_3d_init_guru (mrif_inh_3d_plan *ths, int *N, int M, int *n, int m, float sigma, unsigned nfft_flags, unsigned fftw_flags)
 
void mrif_inh_3d_finalize (mrif_inh_3d_plan *ths)
 
 MMMMMMMMMMMMMMMMMMMMMRI_DEFINE_API (MRI_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 
void mril_inh_2d1d_trafo (mril_inh_2d1d_plan *ths)
 
void mril_inh_2d1d_adjoint (mril_inh_2d1d_plan *ths)
 
void mril_inh_2d1d_init_guru (mril_inh_2d1d_plan *ths, int *N, int M, int *n, int m, long double sigma, unsigned nfft_flags, unsigned fftw_flags)
 
void mril_inh_2d1d_finalize (mril_inh_2d1d_plan *ths)
 
void mril_inh_3d_trafo (mril_inh_3d_plan *ths)
 
void mril_inh_3d_adjoint (mril_inh_3d_plan *ths)
 
void mril_inh_3d_init_guru (mril_inh_3d_plan *ths, int *N, int M, int *n, int m, long double sigma, unsigned nfft_flags, unsigned fftw_flags)
 
void mril_inh_3d_finalize (mril_inh_3d_plan *ths)
 
void nfsftf_init (nfsftf_plan *plan, int N, int M)
 
void nfsftf_init_advanced (nfsftf_plan *plan, int N, int M, unsigned int nfsft_flags)
 
void nfsftf_init_guru (nfsftf_plan *plan, int N, int M, unsigned int nfsft_flags, unsigned int nfft_flags, int nfft_cutoff)
 
void nfsftf_precompute (int N, float kappa, unsigned int nfsft_flags, unsigned int fpt_flags)
 
void nfsftf_forget (void)
 
void nfsftf_trafo_direct (nfsftf_plan *plan)
 
void nfsftf_adjoint_direct (nfsftf_plan *plan)
 
void nfsftf_trafo (nfsftf_plan *plan)
 
void nfsftf_adjoint (nfsftf_plan *plan)
 
void nfsftf_finalize (nfsftf_plan *plan)
 
void nfsftf_precompute_x (nfsftf_plan *plan)
 
 NNNNNNNNNNNNNNNNNNNNNNNFSFT_DEFINE_API (NFSFT_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 data structure for an NFSFT (nonequispaced fast spherical Fourier transform) plan with long double precision
 
void nfsftl_init (nfsftl_plan *plan, int N, int M)
 
void nfsftl_init_advanced (nfsftl_plan *plan, int N, int M, unsigned int nfsft_flags)
 
void nfsftl_init_guru (nfsftl_plan *plan, int N, int M, unsigned int nfsft_flags, unsigned int nfft_flags, int nfft_cutoff)
 
void nfsftl_precompute (int N, long double kappa, unsigned int nfsft_flags, unsigned int fpt_flags)
 
void nfsftl_forget (void)
 
void nfsftl_trafo_direct (nfsftl_plan *plan)
 
void nfsftl_adjoint_direct (nfsftl_plan *plan)
 
void nfsftl_trafo (nfsftl_plan *plan)
 
void nfsftl_adjoint (nfsftl_plan *plan)
 
void nfsftl_finalize (nfsftl_plan *plan)
 
void nfsftl_precompute_x (nfsftl_plan *plan)
 
fptf_set fptf_init (const int M, const int t, const unsigned int flags)
 
void fptf_precompute (fptf_set set, const int m, float *alpha, float *beta, float *gam, int k_start, const float threshold)
 
void fptf_trafo_direct (fptf_set set, const int m, const fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
void fptf_trafo (fptf_set set, const int m, const fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
void fptf_transposed_direct (fptf_set set, const int m, fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
void fptf_transposed (fptf_set set, const int m, fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
void fptf_finalize (fptf_set set)
 
 FFFFFFFFFFFFFFFFFPT_DEFINE_API (FPT_MANGLE_DOUBLE, FFTW_MANGLE_DOUBLE, double, fftw_complex) typedef struct fptl_set_s_ *fptl_set
 A set of precomputed data for a set of DPT transforms of equal maximum length.
 
fptl_set fptl_init (const int M, const int t, const unsigned int flags)
 
void fptl_precompute (fptl_set set, const int m, long double *alpha, long double *beta, long double *gam, int k_start, const long double threshold)
 
void fptl_trafo_direct (fptl_set set, const int m, const fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
void fptl_trafo (fptl_set set, const int m, const fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
void fptl_transposed_direct (fptl_set set, const int m, fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
void fptl_transposed (fptl_set set, const int m, fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
void fptl_finalize (fptl_set set)
 
void nfsoftf_precompute (nfsoftf_plan *plan)
 
fptf_set nfsoftf_SO3_single_fpt_init (int l, int k, int m, unsigned int flags, int kappa)
 
void nfsoftf_SO3_fpt (fftwf_complex *coeffs, fptf_set set, int l, int k, int m, unsigned int nfsoft_flags)
 
void nfsoftf_SO3_fpt_transposed (fftwf_complex *coeffs, fptf_set set, int l, int k, int m, unsigned int nfsoft_flags)
 
void nfsoftf_init (nfsoftf_plan *plan, int N, int M)
 
void nfsoftf_init_advanced (nfsoftf_plan *plan, int N, int M, unsigned int nfsoft_flags)
 
void nfsoftf_init_guru (nfsoftf_plan *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa)
 
void nfsoftf_init_guru_advanced (nfsoftf_plan *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa, int nn_oversampled)
 
void nfsoftf_trafo (nfsoftf_plan *plan_nfsoft)
 
void nfsoftf_adjoint (nfsoftf_plan *plan_nfsoft)
 
void nfsoftf_finalize (nfsoftf_plan *plan)
 
int nfsoftf_posN (int n, int m, int B)
 
 NNNNNNNNNNNNNNNNNNNNNNNNNNNNFSOFT_DEFINE_API (NFSOFT_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, FPT_MANGLE_DOUBLE, double, fftw_complex) typedef struct nfsoftl_plan_
 
void nfsoftl_precompute (nfsoftl_plan *plan)
 
fptl_set nfsoftl_SO3_single_fpt_init (int l, int k, int m, unsigned int flags, int kappa)
 
void nfsoftl_SO3_fpt (fftwl_complex *coeffs, fptl_set set, int l, int k, int m, unsigned int nfsoft_flags)
 
void nfsoftl_SO3_fpt_transposed (fftwl_complex *coeffs, fptl_set set, int l, int k, int m, unsigned int nfsoft_flags)
 
void nfsoftl_init (nfsoftl_plan *plan, int N, int M)
 
void nfsoftl_init_advanced (nfsoftl_plan *plan, int N, int M, unsigned int nfsoft_flags)
 
void nfsoftl_init_guru (nfsoftl_plan *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa)
 
void nfsoftl_init_guru_advanced (nfsoftl_plan *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa, int nn_oversampled)
 
void nfsoftl_trafo (nfsoftl_plan *plan_nfsoft)
 
void nfsoftl_adjoint (nfsoftl_plan *plan_nfsoft)
 
void nfsoftl_finalize (nfsoftl_plan *plan)
 
int nfsoftl_posN (int n, int m, int B)
 
void solverf_init_advanced_complex (solverf_plan_complex *ths, nfftf_mv_plan_complex *mv, unsigned flags)
 
void solverf_init_complex (solverf_plan_complex *ths, nfftf_mv_plan_complex *mv)
 
void solverf_before_loop_complex (solverf_plan_complex *ths)
 
void solverf_loop_one_step_complex (solverf_plan_complex *ths)
 
void solverf_finalize_complex (solverf_plan_complex *ths)
 
void solverf_init_advanced_double (solverf_plan_double *ths, nfftf_mv_plan_double *mv, unsigned flags)
 
void solverf_init_double (solverf_plan_double *ths, nfftf_mv_plan_double *mv)
 
void solverf_before_loop_double (solverf_plan_double *ths)
 
void solverf_loop_one_step_double (solverf_plan_double *ths)
 
void solverf_finalize_double (solverf_plan_double *ths)
 
 SSSSSSSSSSSSSSSSSSSSSSSSSSSSSOLVER_DEFINE_API (SOLVER_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 data structure for an inverse NFFT plan with long double precision
 
void solverl_init_advanced_complex (solverl_plan_complex *ths, nfftl_mv_plan_complex *mv, unsigned flags)
 
void solverl_init_complex (solverl_plan_complex *ths, nfftl_mv_plan_complex *mv)
 
void solverl_before_loop_complex (solverl_plan_complex *ths)
 
void solverl_loop_one_step_complex (solverl_plan_complex *ths)
 
void solverl_finalize_complex (solverl_plan_complex *ths)
 
void solverl_init_advanced_double (solverl_plan_double *ths, nfftl_mv_plan_double *mv, unsigned flags)
 
void solverl_init_double (solverl_plan_double *ths, nfftl_mv_plan_double *mv)
 
void solverl_before_loop_double (solverl_plan_double *ths)
 
void solverl_loop_one_step_double (solverl_plan_double *ths)
 
void solverl_finalize_double (solverl_plan_double *ths)
 
float nfftf_drand48 (void)
 
void nfftf_srand48 (long int seed)
 
void nfftf_vrand_unit_complex (fftwf_complex *x, const NFFT_INT n)
 Inits a vector of random complex numbers in $[0,1]\times[0,1]{\rm i}$. More...
 
void nfftf_vrand_shifted_unit_double (float *x, const NFFT_INT n)
 Inits a vector of random double numbers in $[-1/2,1/2]$. More...
 
void nfftf_vrand_real (float *x, const NFFT_INT n, const float a, const float b)
 
void nfftf_vpr_double (float *x, const NFFT_INT n, const char *text)
 Print real vector to standard output.
 
void nfftf_vpr_complex (fftwf_complex *x, const NFFT_INT n, const char *text)
 Print complex vector to standard output.
 
NFFT_INT nfftf_get_num_threads (void)
 
void nfftf_set_num_threads (NFFT_INT nthreads)
 
NFFT_INT nfftf_has_threads_enabled (void)
 
float nfftf_clock_gettime_seconds (void)
 
float nfftf_error_l_infty_complex (const fftwf_complex *x, const fftwf_complex *y, const NFFT_INT n)
 
float nfftf_error_l_infty_1_complex (const fftwf_complex *x, const fftwf_complex *y, const NFFT_INT n, const fftwf_complex *z, const NFFT_INT m)
 
NFFT_INT nfftf_exp2i (const NFFT_INT a)
 
NFFT_INT nfftf_next_power_of_2 (const NFFT_INT N)
 
float nfftf_dot_complex (fftwf_complex *x, NFFT_INT n)
 Computes the inner/dot product $x^H x$.
 
void nfftf_upd_axpy_complex (fftwf_complex *x, float a, fftwf_complex *y, NFFT_INT n)
 Updates $x \leftarrow a x + y$.
 
void nfftf_fftshift_complex (fftwf_complex *x, NFFT_INT d, NFFT_INT *N)
 Swaps each half over N[d]/2.
 
void nfftf_fftshift_complex_int (fftwf_complex *x, int d, int *N)
 
void nfftf_get_version (unsigned *major, unsigned *minor, unsigned *patch)
 Return library version.
 
const char * nfftf_get_window_name ()
 
NFFT_INT nfftf_get_default_window_cut_off ()
 
 NNNNNNNNNNNNNNNNNNNNNNNFFT_DEFINE_UTIL_API (NFFT_MANGLE_DOUBLE, double, fftw_complex) long double nfftl_drand48(void)
 
void nfftl_srand48 (long int seed)
 
void nfftl_vrand_unit_complex (fftwl_complex *x, const NFFT_INT n)
 Inits a vector of random complex numbers in $[0,1]\times[0,1]{\rm i}$. More...
 
void nfftl_vrand_shifted_unit_double (long double *x, const NFFT_INT n)
 Inits a vector of random double numbers in $[-1/2,1/2]$. More...
 
void nfftl_vrand_real (long double *x, const NFFT_INT n, const long double a, const long double b)
 
void nfftl_vpr_double (long double *x, const NFFT_INT n, const char *text)
 Print real vector to standard output.
 
void nfftl_vpr_complex (fftwl_complex *x, const NFFT_INT n, const char *text)
 Print complex vector to standard output.
 
NFFT_INT nfftl_get_num_threads (void)
 
void nfftl_set_num_threads (NFFT_INT nthreads)
 
NFFT_INT nfftl_has_threads_enabled (void)
 
long double nfftl_clock_gettime_seconds (void)
 
long double nfftl_error_l_infty_complex (const fftwl_complex *x, const fftwl_complex *y, const NFFT_INT n)
 
long double nfftl_error_l_infty_1_complex (const fftwl_complex *x, const fftwl_complex *y, const NFFT_INT n, const fftwl_complex *z, const NFFT_INT m)
 
NFFT_INT nfftl_exp2i (const NFFT_INT a)
 
NFFT_INT nfftl_next_power_of_2 (const NFFT_INT N)
 
long double nfftl_dot_complex (fftwl_complex *x, NFFT_INT n)
 Computes the inner/dot product $x^H x$.
 
void nfftl_upd_axpy_complex (fftwl_complex *x, long double a, fftwl_complex *y, NFFT_INT n)
 Updates $x \leftarrow a x + y$.
 
void nfftl_fftshift_complex (fftwl_complex *x, NFFT_INT d, NFFT_INT *N)
 Swaps each half over N[d]/2.
 
void nfftl_fftshift_complex_int (fftwl_complex *x, int d, int *N)
 
void nfftl_get_version (unsigned *major, unsigned *minor, unsigned *patch)
 Return library version.
 
const char * nfftl_get_window_name ()
 
NFFT_INT nfftl_get_default_window_cut_off ()
 

Variables

nfftf_malloc_type_function nfftf_malloc_hook
 
nfftf_free_type_function nfftf_free_hook
 
nfftf_die_type_function nfftf_die_hook
 
nfftl_malloc_type_function nfftl_malloc_hook
 
nfftl_free_type_function nfftl_free_hook
 
nfftl_die_type_function nfftl_die_hook
 
*We expand this macro for each supported precision * X
 
*We expand this macro for each supported precision Y
 
*We expand this macro for each supported precision R
 
 nfftf_plan
 
 nfftl_mv_plan_complex
 
 nfftl_plan
 
 nfctl_plan
 
 nfstl_plan
 
 nnfftl_plan
 
 nsfftl_plan
 
 mril_inh_2d1d_plan
 
 nfsftl_plan
 
 nfsoftl_plan
 
 solverl_plan_complex
 

Detailed Description

Header file for the nfft3 library.

Header file for NFFT3

Definition in file nfft3.h.

Macro Definition Documentation

◆ MACRO_MV_PLAN

#define MACRO_MV_PLAN (   RC)
Value:
NFFT_INT N_total; \
NFFT_INT M_total; \
RC *f_hat; \
RC *f; \
void (*mv_trafo)(void*); \
void (*mv_adjoint)(void*);

Adjoint transform.

Macros for public members inherited by all plan structures.

Definition at line 66 of file nfft3.h.

◆ NFFT_DEFINE_MALLOC_API

#define NFFT_DEFINE_MALLOC_API (   X)
Value:
/* our own memory allocation and exit functions */ \
NFFT_EXTERN void *X(malloc)(size_t n); \
NFFT_EXTERN void X(free)(void *p); \
NFFT_EXTERN void X(die)(const char *s); \
\
/* You can replace the hooks with your own functions, if necessary. We */ \
/* need this for the Matlab interface. */ \
typedef void *(*X(malloc_type_function)) (size_t n); \
typedef void (*X(free_type_function)) (void *p); \
typedef void (*X(die_type_function)) (const char *errString); \
NFFT_EXTERN X(malloc_type_function) X(malloc_hook); \
NFFT_EXTERN X(free_type_function) X(free_hook); \
NFFT_EXTERN X(die_type_function) X(die_hook);
*We expand this macro for each supported precision * X
Definition: nfft3.h:99

Definition at line 75 of file nfft3.h.

◆ MRI_DEFINE_API

#define MRI_DEFINE_API (   X,
  Z,
  R,
 
)
Value:
typedef struct\
{\
MACRO_MV_PLAN(C)\
Z(plan) plan;\
int N3;\
R sigma3;\
R *t;\
R *w;\
} X(inh_2d1d_plan);\
\
typedef struct\
{\
MACRO_MV_PLAN(C)\
Z(plan) plan;\
int N3;\
R sigma3;\
R *t;\
R *w;\
} X(inh_3d_plan);\
\
void X(inh_2d1d_trafo)(X(inh_2d1d_plan) *ths); \
void X(inh_2d1d_adjoint)(X(inh_2d1d_plan) *ths); \
void X(inh_2d1d_init_guru)(X(inh_2d1d_plan) *ths, int *N, int M, int *n, \
int m, R sigma, unsigned nfft_flags, unsigned fftw_flags); \
void X(inh_2d1d_finalize)(X(inh_2d1d_plan) *ths); \
void X(inh_3d_trafo)(X(inh_3d_plan) *ths); \
void X(inh_3d_adjoint)(X(inh_3d_plan) *ths); \
void X(inh_3d_init_guru)(X(inh_3d_plan) *ths, int *N, int M, int *n, \
int m, R sigma, unsigned nfft_flags, unsigned fftw_flags); \
void X(inh_3d_finalize)(X(inh_3d_plan) *ths);

Definition at line 480 of file nfft3.h.

◆ FPT_DEFINE_API

#define FPT_DEFINE_API (   X,
  Y,
  R,
 
)
Value:
typedef struct X(set_s_) *X(set); \
\
NFFT_EXTERN X(set) X(init)(const int M, const int t, const unsigned int flags); \
NFFT_EXTERN void X(precompute)(X(set) set, const int m, R *alpha, R *beta, \
R *gam, int k_start, const R threshold); \
NFFT_EXTERN void X(trafo_direct)(X(set) set, const int m, const C *x, C *y, \
const int k_end, const unsigned int flags); \
NFFT_EXTERN void X(trafo)(X(set) set, const int m, const C *x, C *y, \
const int k_end, const unsigned int flags); \
NFFT_EXTERN void X(transposed_direct)(X(set) set, const int m, C *x, \
C *y, const int k_end, const unsigned int flags); \
NFFT_EXTERN void X(transposed)(X(set) set, const int m, C *x, \
C *y, const int k_end, const unsigned int flags); \
NFFT_EXTERN void X(finalize)(X(set) set);

Definition at line 597 of file nfft3.h.

◆ NFSOFT_DEFINE_API

#define NFSOFT_DEFINE_API (   X,
  Y,
  Z,
  R,
 
)
Value:
typedef struct X(plan_)\
{\
MACRO_MV_PLAN(C) \
R *x; \
/* internal use only */\
C *wig_coeffs; \
C *cheby; \
C *aux; \
int t; \
unsigned int flags; \
Y(plan) p_nfft; \
Z(set) *internal_fpt_set; \
int nthreads; \
} X(plan);\
\
NFFT_EXTERN void X(precompute)(X(plan) *plan); \
NFFT_EXTERN Z(set) X(SO3_single_fpt_init)(int l, int k, int m, unsigned int flags, int kappa); \
NFFT_EXTERN void X(SO3_fpt)(C *coeffs, Z(set) set, int l, int k, int m, unsigned int nfsoft_flags); \
NFFT_EXTERN void X(SO3_fpt_transposed)(C *coeffs, Z(set) set,int l, int k, int m,unsigned int nfsoft_flags); \
NFFT_EXTERN void X(init)(X(plan) *plan, int N, int M); \
NFFT_EXTERN void X(init_advanced)(X(plan) *plan, int N, int M,unsigned int nfsoft_flags); \
NFFT_EXTERN void X(init_guru)(X(plan) *plan, int N, int M,unsigned int nfsoft_flags,unsigned int nfft_flags,int nfft_cutoff,int fpt_kappa); \
NFFT_EXTERN void X(init_guru_advanced)(X(plan) *plan, int N, int M,unsigned int nfsoft_flags,unsigned int nfft_flags,int nfft_cutoff,int fpt_kappa, int nn_oversampled); \
NFFT_EXTERN void X(trafo)(X(plan) *plan_nfsoft); \
NFFT_EXTERN void X(adjoint)(X(plan) *plan_nfsoft); \
NFFT_EXTERN void X(finalize)(X(plan) *plan); \
NFFT_EXTERN int X(posN)(int n,int m, int B);

Definition at line 641 of file nfft3.h.

Function Documentation

◆ __attribute__()

struct __attribute__ ( (__packed__)  )

data structure for an NFFT (nonequispaced fast Fourier transform) plan with float precision

data structure for an NFFT (nonequispaced fast Fourier transform) plan with long double precision

Definition at line 99 of file nfft3.h.

◆ nfftf_vrand_unit_complex()

void nfftf_vrand_unit_complex ( fftwf_complex *  x,
const NFFT_INT  n 
)

Inits a vector of random complex numbers in $[0,1]\times[0,1]{\rm i}$.


◆ nfftf_vrand_shifted_unit_double()

void nfftf_vrand_shifted_unit_double ( float *  x,
const NFFT_INT  n 
)

Inits a vector of random double numbers in $[-1/2,1/2]$.


◆ nfftf_get_window_name()

const char* nfftf_get_window_name ( )
  • Return name of window function. * * The window function to be used is configured at compile time.

◆ nfftl_vrand_unit_complex()

void nfftl_vrand_unit_complex ( fftwl_complex *  x,
const NFFT_INT  n 
)

Inits a vector of random complex numbers in $[0,1]\times[0,1]{\rm i}$.


◆ nfftl_vrand_shifted_unit_double()

void nfftl_vrand_shifted_unit_double ( long double *  x,
const NFFT_INT  n 
)

Inits a vector of random double numbers in $[-1/2,1/2]$.


◆ nfftl_get_window_name()

const char* nfftl_get_window_name ( )
  • Return name of window function. * * The window function to be used is configured at compile time.