NFFT  3.3.2alpha
Data Structures | Macros | Typedefs | Functions | Variables
nfft3.h File Reference
#include <fftw3.h>

Go to the source code of this file.

Data Structures

struct  nfftf_mv_plan_complex
 
struct  nfftf_mv_plan_double
 
struct  nfftf_plan
 data structure for an NFFT (nonequispaced fast Fourier transform) plan with float precision More...
 
struct  nfftl_mv_plan_double
 
struct  nfftl_plan
 data structure for an NFFT (nonequispaced fast Fourier transform) plan with long double precision More...
 
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_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)
 
#define FPT_NO_FAST_ALGORITHM   (1U << 2)
 
#define FPT_NO_DIRECT_ALGORITHM   (1U << 3)
 
#define FPT_PERSISTENT_DATA   (1U << 4)
 
#define FPT_FUNCTION_VALUES   (1U << 5)
 
#define FPT_AL_SYMMETRY   (1U << 6)
 
#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_INDEX_TWO(m, n, l, B)   ((B+1)*(B+1)+(B+1)*(B+1)*(m+B)-((m-1)*m*(2*m-1)+(B+1)*(B+2)*(2*B+3))/6)+(posN(n,m,B))+(l-MAX(ABS(m),ABS(n)))
 
#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)
 
NFFT_EXTERN void nfftf_free (void *p)
 
NFFT_EXTERN void nfftf_die (const char *s)
 
NFFT_EXTERN NFFT_MANGLE_FLOAT (malloc_type_function) nfftf_malloc_hook
 
NFFT_EXTERN NFFT_MANGLE_FLOAT (free_type_function) nfftf_free_hook
 
NFFT_EXTERN NFFT_MANGLE_FLOAT (die_type_function) nfftf_die_hook
 
 NNFFT_DEFINE_MALLOC_API (NFFT_MANGLE_DOUBLE) extern void *nfftl_malloc(size_t n)
 
NFFT_EXTERN void nfftl_free (void *p)
 
NFFT_EXTERN void nfftl_die (const char *s)
 
NFFT_EXTERN NFFT_MANGLE_LONG_DOUBLE (malloc_type_function) nfftl_malloc_hook
 
NFFT_EXTERN NFFT_MANGLE_LONG_DOUBLE (free_type_function) nfftl_free_hook
 
NFFT_EXTERN NFFT_MANGLE_LONG_DOUBLE (die_type_function) nfftl_die_hook
 
void nfftf_trafo_direct (const NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_adjoint_direct (const NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_trafo (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_trafo_1d (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_trafo_2d (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_trafo_3d (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_adjoint (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_adjoint_1d (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_adjoint_2d (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_adjoint_3d (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_init_1d (NFFT_MANGLE_FLOAT(plan) *ths, int N1, int M)
 
NFFT_EXTERN void nfftf_init_2d (NFFT_MANGLE_FLOAT(plan) *ths, int N1, int N2, int M)
 
NFFT_EXTERN void nfftf_init_3d (NFFT_MANGLE_FLOAT(plan) *ths, int N1, int N2, int N3, int M)
 
NFFT_EXTERN void nfftf_init (NFFT_MANGLE_FLOAT(plan) *ths, int d, int *N, int M)
 
NFFT_EXTERN void nfftf_init_guru (NFFT_MANGLE_FLOAT(plan) *ths, int d, int *N, int M, int *n, int m, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfftf_init_lin (NFFT_MANGLE_FLOAT(plan) *ths, int d, int *N, int M, int *n, int m, int K, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfftf_precompute_one_psi (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_precompute_psi (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_precompute_full_psi (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_precompute_fg_psi (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_precompute_lin_psi (NFFT_MANGLE_FLOAT(plan) *ths)
 
const NFFT_EXTERN char * nfftf_check (NFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfftf_finalize (NFFT_MANGLE_FLOAT(plan) *ths)
 
 NNFFT_DEFINE_API (NFFT_MANGLE_DOUBLE, FFTW_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 
void nfftl_trafo_direct (const NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_adjoint_direct (const NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_trafo (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_trafo_1d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_trafo_2d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_trafo_3d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_adjoint (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_adjoint_1d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_adjoint_2d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_adjoint_3d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_init_1d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths, int N1, int M)
 
NFFT_EXTERN void nfftl_init_2d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths, int N1, int N2, int M)
 
NFFT_EXTERN void nfftl_init_3d (NFFT_MANGLE_LONG_DOUBLE(plan) *ths, int N1, int N2, int N3, int M)
 
NFFT_EXTERN void nfftl_init (NFFT_MANGLE_LONG_DOUBLE(plan) *ths, int d, int *N, int M)
 
NFFT_EXTERN void nfftl_init_guru (NFFT_MANGLE_LONG_DOUBLE(plan) *ths, int d, int *N, int M, int *n, int m, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfftl_init_lin (NFFT_MANGLE_LONG_DOUBLE(plan) *ths, int d, int *N, int M, int *n, int m, int K, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfftl_precompute_one_psi (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_precompute_psi (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_precompute_full_psi (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_precompute_fg_psi (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_precompute_lin_psi (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
const NFFT_EXTERN char * nfftl_check (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfftl_finalize (NFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
void nfctf_init_1d (NFCT_MANGLE_FLOAT(plan) *ths_plan, int N0, int M_total)
 
NFFT_EXTERN void nfctf_init_2d (NFCT_MANGLE_FLOAT(plan) *ths_plan, int N0, int N1, int M_total)
 
NFFT_EXTERN void nfctf_init_3d (NFCT_MANGLE_FLOAT(plan) *ths_plan, int N0, int N1, int N2, int M_total)
 
NFFT_EXTERN void nfctf_init (NFCT_MANGLE_FLOAT(plan) *ths_plan, int d, int *N, int M_total)
 
NFFT_EXTERN void nfctf_init_guru (NFCT_MANGLE_FLOAT(plan) *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfctf_precompute_one_psi (NFCT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfctf_precompute_psi (NFCT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfctf_precompute_full_psi (NFCT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfctf_precompute_fg_psi (NFCT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfctf_precompute_lin_psi (NFCT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfctf_trafo (NFCT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nfctf_trafo_direct (const NFCT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nfctf_adjoint (NFCT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nfctf_adjoint_direct (const NFCT_MANGLE_FLOAT(plan) *ths_plan)
 
const NFFT_EXTERN char * nfctf_check (NFCT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfctf_finalize (NFCT_MANGLE_FLOAT(plan) *ths_plan)
 
 NNFCT_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 (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int N0, int M_total)
 
NFFT_EXTERN void nfctl_init_2d (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int N0, int N1, int M_total)
 
NFFT_EXTERN void nfctl_init_3d (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int N0, int N1, int N2, int M_total)
 
NFFT_EXTERN void nfctl_init (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int d, int *N, int M_total)
 
NFFT_EXTERN void nfctl_init_guru (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfctl_precompute_one_psi (NFCT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfctl_precompute_psi (NFCT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfctl_precompute_full_psi (NFCT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfctl_precompute_fg_psi (NFCT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfctl_precompute_lin_psi (NFCT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfctl_trafo (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nfctl_trafo_direct (const NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nfctl_adjoint (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nfctl_adjoint_direct (const NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
const NFFT_EXTERN char * nfctl_check (NFCT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfctl_finalize (NFCT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
void nfstf_init_1d (NFST_MANGLE_FLOAT(plan) *ths_plan, int N0, int M_total)
 
NFFT_EXTERN void nfstf_init_2d (NFST_MANGLE_FLOAT(plan) *ths_plan, int N0, int N1, int M_total)
 
NFFT_EXTERN void nfstf_init_3d (NFST_MANGLE_FLOAT(plan) *ths_plan, int N0, int N1, int N2, int M_total)
 
NFFT_EXTERN void nfstf_init (NFST_MANGLE_FLOAT(plan) *ths_plan, int d, int *N, int M_total)
 
NFFT_EXTERN void nfstf_init_guru (NFST_MANGLE_FLOAT(plan) *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfstf_precompute_one_psi (NFST_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfstf_precompute_psi (NFST_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfstf_precompute_full_psi (NFST_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfstf_precompute_fg_psi (NFST_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfstf_precompute_lin_psi (NFST_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfstf_trafo (NFST_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nfstf_trafo_direct (const NFST_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nfstf_adjoint (NFST_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nfstf_adjoint_direct (const NFST_MANGLE_FLOAT(plan) *ths_plan)
 
const NFFT_EXTERN char * nfstf_check (NFST_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nfstf_finalize (NFST_MANGLE_FLOAT(plan) *ths_plan)
 
 NNFST_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 (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan, int N0, int M_total)
 
NFFT_EXTERN void nfstl_init_2d (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan, int N0, int N1, int M_total)
 
NFFT_EXTERN void nfstl_init_3d (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan, int N0, int N1, int N2, int M_total)
 
NFFT_EXTERN void nfstl_init (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan, int d, int *N, int M_total)
 
NFFT_EXTERN void nfstl_init_guru (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
NFFT_EXTERN void nfstl_precompute_one_psi (NFST_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfstl_precompute_psi (NFST_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfstl_precompute_full_psi (NFST_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfstl_precompute_fg_psi (NFST_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfstl_precompute_lin_psi (NFST_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfstl_trafo (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nfstl_trafo_direct (const NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nfstl_adjoint (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nfstl_adjoint_direct (const NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
const NFFT_EXTERN char * nfstl_check (NFST_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nfstl_finalize (NFST_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
void nnfftf_init (NNFFT_MANGLE_FLOAT(plan) *ths_plan, int d, int N_total, int M_total, int *N)
 
NFFT_EXTERN void nnfftf_init_1d (NNFFT_MANGLE_FLOAT(plan) *ths_plan, int N, int M_total)
 
NFFT_EXTERN void nnfftf_init_guru (NNFFT_MANGLE_FLOAT(plan) *ths_plan, int d, int N_total, int M_total, int *N, int *N1, int m, unsigned nnfft_flags)
 
NFFT_EXTERN void nnfftf_trafo_direct (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_adjoint_direct (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_trafo (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_adjoint (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_precompute_lin_psi (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_precompute_psi (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_precompute_full_psi (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_precompute_phi_hut (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
NFFT_EXTERN void nnfftf_precompute_one_psi (NNFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nnfftf_finalize (NNFFT_MANGLE_FLOAT(plan) *ths_plan)
 
 NNNNFFT_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 (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int d, int N_total, int M_total, int *N)
 
NFFT_EXTERN void nnfftl_init_1d (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int N, int M_total)
 
NFFT_EXTERN void nnfftl_init_guru (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan, int d, int N_total, int M_total, int *N, int *N1, int m, unsigned nnfft_flags)
 
NFFT_EXTERN void nnfftl_trafo_direct (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_adjoint_direct (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_trafo (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_adjoint (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_precompute_lin_psi (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_precompute_psi (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_precompute_full_psi (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_precompute_phi_hut (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
NFFT_EXTERN void nnfftl_precompute_one_psi (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nnfftl_finalize (NNFFT_MANGLE_LONG_DOUBLE(plan) *ths_plan)
 
void nsfftf_trafo_direct (NSFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nsfftf_adjoint_direct (NSFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nsfftf_trafo (NSFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nsfftf_adjoint (NSFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nsfftf_cp (NSFFT_MANGLE_FLOAT(plan) *ths, NFFT_MANGLE_FLOAT(plan) *ths_nfft)
 
NFFT_EXTERN void nsfftf_init_random_nodes_coeffs (NSFFT_MANGLE_FLOAT(plan) *ths)
 
NFFT_EXTERN void nsfftf_init (NSFFT_MANGLE_FLOAT(plan) *ths, int d, int J, int M, int m, unsigned flags)
 
NFFT_EXTERN void nsfftf_finalize (NSFFT_MANGLE_FLOAT(plan) *ths)
 
 NNNSFFT_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 (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nsfftl_adjoint_direct (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nsfftl_trafo (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nsfftl_adjoint (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nsfftl_cp (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths, NFFT_MANGLE_LONG_DOUBLE(plan) *ths_nfft)
 
NFFT_EXTERN void nsfftl_init_random_nodes_coeffs (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
NFFT_EXTERN void nsfftl_init (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths, int d, int J, int M, int m, unsigned flags)
 
NFFT_EXTERN void nsfftl_finalize (NSFFT_MANGLE_LONG_DOUBLE(plan) *ths)
 
void mrif_inh_2d1d_trafo (MRI_MANGLE_FLOAT(inh_2d1d_plan) *ths)
 
void mrif_inh_2d1d_adjoint (MRI_MANGLE_FLOAT(inh_2d1d_plan) *ths)
 
void mrif_inh_2d1d_init_guru (MRI_MANGLE_FLOAT(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 (MRI_MANGLE_FLOAT(inh_2d1d_plan) *ths)
 
void mrif_inh_3d_trafo (MRI_MANGLE_FLOAT(inh_3d_plan) *ths)
 
void mrif_inh_3d_adjoint (MRI_MANGLE_FLOAT(inh_3d_plan) *ths)
 
void mrif_inh_3d_init_guru (MRI_MANGLE_FLOAT(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 (MRI_MANGLE_FLOAT(inh_3d_plan) *ths)
 
 MMMRI_DEFINE_API (MRI_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, double, fftw_complex) typedef struct
 
void mril_inh_2d1d_trafo (MRI_MANGLE_LONG_DOUBLE(inh_2d1d_plan) *ths)
 
void mril_inh_2d1d_adjoint (MRI_MANGLE_LONG_DOUBLE(inh_2d1d_plan) *ths)
 
void mril_inh_2d1d_init_guru (MRI_MANGLE_LONG_DOUBLE(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 (MRI_MANGLE_LONG_DOUBLE(inh_2d1d_plan) *ths)
 
void mril_inh_3d_trafo (MRI_MANGLE_LONG_DOUBLE(inh_3d_plan) *ths)
 
void mril_inh_3d_adjoint (MRI_MANGLE_LONG_DOUBLE(inh_3d_plan) *ths)
 
void mril_inh_3d_init_guru (MRI_MANGLE_LONG_DOUBLE(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 (MRI_MANGLE_LONG_DOUBLE(inh_3d_plan) *ths)
 
void nfsftf_init (NFSFT_MANGLE_FLOAT(plan) *plan, int N, int M)
 
NFFT_EXTERN void nfsftf_init_advanced (NFSFT_MANGLE_FLOAT(plan) *plan, int N, int M, unsigned int nfsft_flags)
 
NFFT_EXTERN void nfsftf_init_guru (NFSFT_MANGLE_FLOAT(plan) *plan, int N, int M, unsigned int nfsft_flags, unsigned int nfft_flags, int nfft_cutoff)
 
NFFT_EXTERN void nfsftf_precompute (int N, float kappa, unsigned int nfsft_flags, unsigned int fpt_flags)
 
NFFT_EXTERN void nfsftf_forget (void)
 
NFFT_EXTERN void nfsftf_trafo_direct (NFSFT_MANGLE_FLOAT(plan) *plan)
 
NFFT_EXTERN void nfsftf_adjoint_direct (NFSFT_MANGLE_FLOAT(plan) *plan)
 
NFFT_EXTERN void nfsftf_trafo (NFSFT_MANGLE_FLOAT(plan) *plan)
 
NFFT_EXTERN void nfsftf_adjoint (NFSFT_MANGLE_FLOAT(plan) *plan)
 
NFFT_EXTERN void nfsftf_finalize (NFSFT_MANGLE_FLOAT(plan) *plan)
 
NFFT_EXTERN void nfsftf_precompute_x (NFSFT_MANGLE_FLOAT(plan) *plan)
 
 NNNFSFT_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 (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan, int N, int M)
 
NFFT_EXTERN void nfsftl_init_advanced (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan, int N, int M, unsigned int nfsft_flags)
 
NFFT_EXTERN void nfsftl_init_guru (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan, int N, int M, unsigned int nfsft_flags, unsigned int nfft_flags, int nfft_cutoff)
 
NFFT_EXTERN void nfsftl_precompute (int N, long double kappa, unsigned int nfsft_flags, unsigned int fpt_flags)
 
NFFT_EXTERN void nfsftl_forget (void)
 
NFFT_EXTERN void nfsftl_trafo_direct (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
NFFT_EXTERN void nfsftl_adjoint_direct (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
NFFT_EXTERN void nfsftl_trafo (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
NFFT_EXTERN void nfsftl_adjoint (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
NFFT_EXTERN void nfsftl_finalize (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
NFFT_EXTERN void nfsftl_precompute_x (NFSFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
 FPT_MANGLE_FLOAT (set) fptf_init(const int M
 
NFFT_EXTERN void fptf_precompute (FPT_MANGLE_FLOAT(set) set, const int m, float *alpha, float *beta, float *gam, int k_start, const float threshold)
 
NFFT_EXTERN void fptf_trafo_direct (FPT_MANGLE_FLOAT(set) set, const int m, const fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptf_trafo (FPT_MANGLE_FLOAT(set) set, const int m, const fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptf_transposed_direct (FPT_MANGLE_FLOAT(set) set, const int m, fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptf_transposed (FPT_MANGLE_FLOAT(set) set, const int m, fftwf_complex *x, fftwf_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptf_finalize (FPT_MANGLE_FLOAT(set) set)
 
 FFPT_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.
 
 FPT_MANGLE_LONG_DOUBLE (set) fptl_init(const int M
 
NFFT_EXTERN void fptl_precompute (FPT_MANGLE_LONG_DOUBLE(set) set, const int m, long double *alpha, long double *beta, long double *gam, int k_start, const long double threshold)
 
NFFT_EXTERN void fptl_trafo_direct (FPT_MANGLE_LONG_DOUBLE(set) set, const int m, const fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptl_trafo (FPT_MANGLE_LONG_DOUBLE(set) set, const int m, const fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptl_transposed_direct (FPT_MANGLE_LONG_DOUBLE(set) set, const int m, fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptl_transposed (FPT_MANGLE_LONG_DOUBLE(set) set, const int m, fftwl_complex *x, fftwl_complex *y, const int k_end, const unsigned int flags)
 
NFFT_EXTERN void fptl_finalize (FPT_MANGLE_LONG_DOUBLE(set) set)
 
void nfsoftf_precompute (NFSOFT_MANGLE_FLOAT(plan) *plan)
 
NFFT_EXTERN void nfsoftf_SO3_fpt (fftwf_complex *coeffs, FPT_MANGLE_FLOAT(set) set, int l, int k, int m, unsigned int nfsoft_flags)
 
NFFT_EXTERN void nfsoftf_SO3_fpt_transposed (fftwf_complex *coeffs, FPT_MANGLE_FLOAT(set) set, int l, int k, int m, unsigned int nfsoft_flags)
 
NFFT_EXTERN void nfsoftf_init (NFSOFT_MANGLE_FLOAT(plan) *plan, int N, int M)
 
NFFT_EXTERN void nfsoftf_init_advanced (NFSOFT_MANGLE_FLOAT(plan) *plan, int N, int M, unsigned int nfsoft_flags)
 
NFFT_EXTERN void nfsoftf_init_guru (NFSOFT_MANGLE_FLOAT(plan) *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa)
 
NFFT_EXTERN void nfsoftf_trafo (NFSOFT_MANGLE_FLOAT(plan) *plan_nfsoft)
 
NFFT_EXTERN void nfsoftf_adjoint (NFSOFT_MANGLE_FLOAT(plan) *plan_nfsoft)
 
NFFT_EXTERN void nfsoftf_finalize (NFSOFT_MANGLE_FLOAT(plan) *plan)
 
NFFT_EXTERN int nfsoftf_posN (int n, int m, int B)
 
 NNNNFSOFT_DEFINE_API (NFSOFT_MANGLE_DOUBLE, NFFT_MANGLE_DOUBLE, FPT_MANGLE_DOUBLE, double, fftw_complex) typedef struct nfsoftl_plan_
 
void nfsoftl_precompute (NFSOFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
NFFT_EXTERN void nfsoftl_SO3_fpt (fftwl_complex *coeffs, FPT_MANGLE_LONG_DOUBLE(set) set, int l, int k, int m, unsigned int nfsoft_flags)
 
NFFT_EXTERN void nfsoftl_SO3_fpt_transposed (fftwl_complex *coeffs, FPT_MANGLE_LONG_DOUBLE(set) set, int l, int k, int m, unsigned int nfsoft_flags)
 
NFFT_EXTERN void nfsoftl_init (NFSOFT_MANGLE_LONG_DOUBLE(plan) *plan, int N, int M)
 
NFFT_EXTERN void nfsoftl_init_advanced (NFSOFT_MANGLE_LONG_DOUBLE(plan) *plan, int N, int M, unsigned int nfsoft_flags)
 
NFFT_EXTERN void nfsoftl_init_guru (NFSOFT_MANGLE_LONG_DOUBLE(plan) *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa)
 
NFFT_EXTERN void nfsoftl_trafo (NFSOFT_MANGLE_LONG_DOUBLE(plan) *plan_nfsoft)
 
NFFT_EXTERN void nfsoftl_adjoint (NFSOFT_MANGLE_LONG_DOUBLE(plan) *plan_nfsoft)
 
NFFT_EXTERN void nfsoftl_finalize (NFSOFT_MANGLE_LONG_DOUBLE(plan) *plan)
 
NFFT_EXTERN int nfsoftl_posN (int n, int m, int B)
 
void solverf_init_advanced_complex (SOLVER_MANGLE_FLOAT(plan_complex) *ths, NFFT_MANGLE_FLOAT(mv_plan_complex) *mv, unsigned flags)
 
NFFT_EXTERN void solverf_init_complex (SOLVER_MANGLE_FLOAT(plan_complex) *ths, NFFT_MANGLE_FLOAT(mv_plan_complex) *mv)
 
NFFT_EXTERN void solverf_before_loop_complex (SOLVER_MANGLE_FLOAT(plan_complex) *ths)
 
NFFT_EXTERN void solverf_loop_one_step_complex (SOLVER_MANGLE_FLOAT(plan_complex) *ths)
 
NFFT_EXTERN void solverf_finalize_complex (SOLVER_MANGLE_FLOAT(plan_complex) *ths)
 
NFFT_EXTERN void solverf_init_advanced_double (SOLVER_MANGLE_FLOAT(plan_double) *ths, NFFT_MANGLE_FLOAT(mv_plan_double) *mv, unsigned flags)
 
NFFT_EXTERN void solverf_init_double (SOLVER_MANGLE_FLOAT(plan_double) *ths, NFFT_MANGLE_FLOAT(mv_plan_double) *mv)
 
NFFT_EXTERN void solverf_before_loop_double (SOLVER_MANGLE_FLOAT(plan_double) *ths)
 
NFFT_EXTERN void solverf_loop_one_step_double (SOLVER_MANGLE_FLOAT(plan_double) *ths)
 
NFFT_EXTERN void solverf_finalize_double (SOLVER_MANGLE_FLOAT(plan_double) *ths)
 
 SSSOLVER_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 (SOLVER_MANGLE_LONG_DOUBLE(plan_complex) *ths, NFFT_MANGLE_LONG_DOUBLE(mv_plan_complex) *mv, unsigned flags)
 
NFFT_EXTERN void solverl_init_complex (SOLVER_MANGLE_LONG_DOUBLE(plan_complex) *ths, NFFT_MANGLE_LONG_DOUBLE(mv_plan_complex) *mv)
 
NFFT_EXTERN void solverl_before_loop_complex (SOLVER_MANGLE_LONG_DOUBLE(plan_complex) *ths)
 
NFFT_EXTERN void solverl_loop_one_step_complex (SOLVER_MANGLE_LONG_DOUBLE(plan_complex) *ths)
 
NFFT_EXTERN void solverl_finalize_complex (SOLVER_MANGLE_LONG_DOUBLE(plan_complex) *ths)
 
NFFT_EXTERN void solverl_init_advanced_double (SOLVER_MANGLE_LONG_DOUBLE(plan_double) *ths, NFFT_MANGLE_LONG_DOUBLE(mv_plan_double) *mv, unsigned flags)
 
NFFT_EXTERN void solverl_init_double (SOLVER_MANGLE_LONG_DOUBLE(plan_double) *ths, NFFT_MANGLE_LONG_DOUBLE(mv_plan_double) *mv)
 
NFFT_EXTERN void solverl_before_loop_double (SOLVER_MANGLE_LONG_DOUBLE(plan_double) *ths)
 
NFFT_EXTERN void solverl_loop_one_step_double (SOLVER_MANGLE_LONG_DOUBLE(plan_double) *ths)
 
NFFT_EXTERN void solverl_finalize_double (SOLVER_MANGLE_LONG_DOUBLE(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)
 
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)
 
 NNFFT_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)
 
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)
 

Variables

*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
 
 nfftl_mv_plan_complex
 
 nfctl_plan
 
 nfstl_plan
 
 nnfftl_plan
 
 nsfftl_plan
 
 mril_inh_2d1d_plan
 
 nfsftl_plan
 
const int t
 
const int const unsigned int flags
 
NFFT_EXTERN int k
 
NFFT_EXTERN int int m
 
NFFT_EXTERN int int unsigned int int kappa
 
 nfsoftl_plan
 
 solverl_plan_complex
 

Detailed Description

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.

Definition at line 54 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);

Definition at line 75 of file nfft3.h.

◆ MALLOC_V

#define MALLOC_V   (1U<< 11)
  • additional init flags *‍/

Definition at line 414 of file nfft3.h.

◆ NSDFT

#define NSDFT   (1U<< 12)
  • additional init flags *‍/

Definition at line 464 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.

◆ NFSFT_MANGLE_DOUBLE

#define NFSFT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nfsft_, name)
  • nfsft *‍/

Definition at line 517 of file nfft3.h.

◆ NFSFT_NORMALIZED

#define NFSFT_NORMALIZED   (1U << 0)
  • init flags *‍/

Definition at line 561 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 596 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; \
C *wig_coeffs; \
C *cheby; \
C *aux; \
/* internal use only */\
int t; \
unsigned int flags; \
Y(plan) p_nfft; \
Z(set) internal_fpt_set; \
int fpt_kappa; \
} 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(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 639 of file nfft3.h.

◆ LANDWEBER

#define LANDWEBER   (1U<< 0)
  • init flags *‍/

Definition at line 771 of file nfft3.h.

Function Documentation

◆ 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]$.


◆ 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]$.


X
#define X(name)
Include header for C99 complex datatype.
Definition: fastsum.h:51