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  nfft_mv_plan_complex
 
struct  nfft_mv_plan_double
 
struct  nfftl_mv_plan_complex
 
struct  nfftl_mv_plan_double
 
struct  nfctf_plan
 data structure for an NFCT (nonequispaced fast cosine transform) plan with float precision More...
 
struct  nfct_plan
 data structure for an NFCT (nonequispaced fast cosine transform) plan with double precision More...
 
struct  nfctl_plan
 data structure for an NFCT (nonequispaced fast cosine transform) plan with long double precision More...
 
struct  nfstf_plan
 data structure for an NFST (nonequispaced fast sine transform) plan with float precision More...
 
struct  nfst_plan
 data structure for an NFST (nonequispaced fast sine transform) plan with double precision More...
 
struct  nfstl_plan
 data structure for an NFST (nonequispaced fast sine transform) plan with long double precision More...
 
struct  nnfftf_plan
 data structure for an NNFFT (nonequispaced in time and frequency fast Fourier transform) plan with float precision More...
 
struct  nnfft_plan
 data structure for an NNFFT (nonequispaced in time and frequency fast Fourier transform) plan with double precision More...
 
struct  nnfftl_plan
 data structure for an NNFFT (nonequispaced in time and frequency fast Fourier transform) plan with long double precision More...
 
struct  nsfftf_plan
 data structure for an NSFFT (nonequispaced sparse fast Fourier transform) plan with float precision More...
 
struct  nsfft_plan
 data structure for an NSFFT (nonequispaced sparse fast Fourier transform) plan with double precision More...
 
struct  nsfftl_plan
 data structure for an NSFFT (nonequispaced sparse fast Fourier transform) plan with long double precision More...
 
struct  mrif_inh_2d1d_plan
 
struct  mrif_inh_3d_plan
 
struct  mri_inh_2d1d_plan
 
struct  mri_inh_3d_plan
 
struct  mril_inh_2d1d_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  nfsft_plan
 data structure for an NFSFT (nonequispaced fast spherical Fourier transform) plan with double precision More...
 
struct  nfsftl_plan
 data structure for an NFSFT (nonequispaced fast spherical Fourier transform) plan with long double precision More...
 
struct  nfsoftf_plan_
 
struct  nfsoft_plan_
 
struct  nfsoftl_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  solver_plan_complex
 data structure for an inverse NFFT plan with double precision More...
 
struct  solver_plan_double
 data structure for an inverse NFFT plan with double precision More...
 
struct  solverl_plan_complex
 data structure for an inverse NFFT plan with long double 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.
 
#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 *(* nfft_malloc_type_function) (size_t n)
 
typedef void(* nfft_free_type_function) (void *p)
 
typedef void(* nfft_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 fpt_set_s_fpt_set
 A set of precomputed data for a set of DPT transforms of equal maximum length.
 
typedef struct fptl_set_s_ * fptl_set
 A set of precomputed data for a set of DPT transforms of equal maximum length.
 
typedef struct nfsoftf_plan_ nfsoftf_plan
 
typedef struct nfsoft_plan_ nfsoft_plan
 
typedef struct nfsoftl_plan_ nfsoftl_plan
 

Functions

void * nfftf_malloc (size_t n)
 
void nfftf_free (void *p)
 
void nfftf_die (const char *s)
 
void * nfft_malloc (size_t n)
 
void nfft_free (void *p)
 
void nfft_die (const char *s)
 
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
 
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)
 
void nfft_trafo_direct (const nfft_plan *ths)
 
void nfft_adjoint_direct (const nfft_plan *ths)
 
void nfft_trafo (nfft_plan *ths)
 
void nfft_trafo_1d (nfft_plan *ths)
 
void nfft_trafo_2d (nfft_plan *ths)
 
void nfft_trafo_3d (nfft_plan *ths)
 
void nfft_adjoint (nfft_plan *ths)
 
void nfft_adjoint_1d (nfft_plan *ths)
 
void nfft_adjoint_2d (nfft_plan *ths)
 
void nfft_adjoint_3d (nfft_plan *ths)
 
void nfft_init_1d (nfft_plan *ths, int N1, int M)
 
void nfft_init_2d (nfft_plan *ths, int N1, int N2, int M)
 
void nfft_init_3d (nfft_plan *ths, int N1, int N2, int N3, int M)
 
void nfft_init (nfft_plan *ths, int d, int *N, int M)
 
void nfft_init_guru (nfft_plan *ths, int d, int *N, int M, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfft_init_lin (nfft_plan *ths, int d, int *N, int M, int *n, int m, int K, unsigned flags, unsigned fftw_flags)
 
void nfft_precompute_one_psi (nfft_plan *ths)
 
void nfft_precompute_psi (nfft_plan *ths)
 
void nfft_precompute_full_psi (nfft_plan *ths)
 
void nfft_precompute_fg_psi (nfft_plan *ths)
 
void nfft_precompute_lin_psi (nfft_plan *ths)
 
const char * nfft_check (nfft_plan *ths)
 
void nfft_finalize (nfft_plan *ths)
 
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)
 
void nfct_init_1d (nfct_plan *ths_plan, int N0, int M_total)
 
void nfct_init_2d (nfct_plan *ths_plan, int N0, int N1, int M_total)
 
void nfct_init_3d (nfct_plan *ths_plan, int N0, int N1, int N2, int M_total)
 
void nfct_init (nfct_plan *ths_plan, int d, int *N, int M_total)
 
void nfct_init_guru (nfct_plan *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfct_precompute_one_psi (nfct_plan *ths)
 
void nfct_precompute_psi (nfct_plan *ths)
 
void nfct_precompute_full_psi (nfct_plan *ths)
 
void nfct_precompute_fg_psi (nfct_plan *ths)
 
void nfct_precompute_lin_psi (nfct_plan *ths)
 
void nfct_trafo (nfct_plan *ths_plan)
 
void nfct_trafo_direct (const nfct_plan *ths_plan)
 
void nfct_adjoint (nfct_plan *ths_plan)
 
void nfct_adjoint_direct (const nfct_plan *ths_plan)
 
const char * nfct_check (nfct_plan *ths)
 
void nfct_finalize (nfct_plan *ths_plan)
 
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)
 
void nfst_init_1d (nfst_plan *ths_plan, int N0, int M_total)
 
void nfst_init_2d (nfst_plan *ths_plan, int N0, int N1, int M_total)
 
void nfst_init_3d (nfst_plan *ths_plan, int N0, int N1, int N2, int M_total)
 
void nfst_init (nfst_plan *ths_plan, int d, int *N, int M_total)
 
void nfst_init_guru (nfst_plan *ths_plan, int d, int *N, int M_total, int *n, int m, unsigned flags, unsigned fftw_flags)
 
void nfst_precompute_one_psi (nfst_plan *ths)
 
void nfst_precompute_psi (nfst_plan *ths)
 
void nfst_precompute_full_psi (nfst_plan *ths)
 
void nfst_precompute_fg_psi (nfst_plan *ths)
 
void nfst_precompute_lin_psi (nfst_plan *ths)
 
void nfst_trafo (nfst_plan *ths_plan)
 
void nfst_trafo_direct (const nfst_plan *ths_plan)
 
void nfst_adjoint (nfst_plan *ths_plan)
 
void nfst_adjoint_direct (const nfst_plan *ths_plan)
 
const char * nfst_check (nfst_plan *ths)
 
void nfst_finalize (nfst_plan *ths_plan)
 
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)
 
void nnfft_init (nnfft_plan *ths_plan, int d, int N_total, int M_total, int *N)
 
void nnfft_init_1d (nnfft_plan *ths_plan, int N, int M_total)
 
void nnfft_init_guru (nnfft_plan *ths_plan, int d, int N_total, int M_total, int *N, int *N1, int m, unsigned nnfft_flags)
 
void nnfft_trafo_direct (nnfft_plan *ths_plan)
 
void nnfft_adjoint_direct (nnfft_plan *ths_plan)
 
void nnfft_trafo (nnfft_plan *ths_plan)
 user routines
 
void nnfft_adjoint (nnfft_plan *ths_plan)
 
void nnfft_precompute_lin_psi (nnfft_plan *ths_plan)
 create a lookup table
 
void nnfft_precompute_psi (nnfft_plan *ths_plan)
 
void nnfft_precompute_full_psi (nnfft_plan *ths_plan)
 computes all entries of B explicitly
 
void nnfft_precompute_phi_hut (nnfft_plan *ths_plan)
 initialisation of direct transform
 
void nnfft_precompute_one_psi (nnfft_plan *ths)
 
void nnfft_finalize (nnfft_plan *ths_plan)
 
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)
 
void nsfft_trafo_direct (nsfft_plan *ths)
 
void nsfft_adjoint_direct (nsfft_plan *ths)
 
void nsfft_trafo (nsfft_plan *ths)
 
void nsfft_adjoint (nsfft_plan *ths)
 
void nsfft_cp (nsfft_plan *ths, nfft_plan *ths_nfft)
 
void nsfft_init_random_nodes_coeffs (nsfft_plan *ths)
 
void nsfft_init (nsfft_plan *ths, int d, int J, int M, int m, unsigned flags)
 
void nsfft_finalize (nsfft_plan *ths)
 
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)
 
void mri_inh_2d1d_trafo (mri_inh_2d1d_plan *ths)
 
void mri_inh_2d1d_adjoint (mri_inh_2d1d_plan *ths)
 
void mri_inh_2d1d_init_guru (mri_inh_2d1d_plan *ths, int *N, int M, int *n, int m, double sigma, unsigned nfft_flags, unsigned fftw_flags)
 
void mri_inh_2d1d_finalize (mri_inh_2d1d_plan *ths)
 
void mri_inh_3d_trafo (mri_inh_3d_plan *ths)
 
void mri_inh_3d_adjoint (mri_inh_3d_plan *ths)
 
void mri_inh_3d_init_guru (mri_inh_3d_plan *ths, int *N, int M, int *n, int m, double sigma, unsigned nfft_flags, unsigned fftw_flags)
 
void mri_inh_3d_finalize (mri_inh_3d_plan *ths)
 
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)
 
void nfsft_init (nfsft_plan *plan, int N, int M)
 
void nfsft_init_advanced (nfsft_plan *plan, int N, int M, unsigned int nfsft_flags)
 
void nfsft_init_guru (nfsft_plan *plan, int N, int M, unsigned int nfsft_flags, unsigned int nfft_flags, int nfft_cutoff)
 
void nfsft_precompute (int N, double kappa, unsigned int nfsft_flags, unsigned int fpt_flags)
 
void nfsft_forget (void)
 
void nfsft_trafo_direct (nfsft_plan *plan)
 
void nfsft_adjoint_direct (nfsft_plan *plan)
 
void nfsft_trafo (nfsft_plan *plan)
 
void nfsft_adjoint (nfsft_plan *plan)
 
void nfsft_finalize (nfsft_plan *plan)
 
void nfsft_precompute_x (nfsft_plan *plan)
 
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)
 
fpt_set fpt_init (const int M, const int t, const unsigned int flags)
 
void fpt_precompute (fpt_set set, const int m, double *alpha, double *beta, double *gam, int k_start, const double threshold)
 
void fpt_trafo_direct (fpt_set set, const int m, const fftw_complex *x, fftw_complex *y, const int k_end, const unsigned int flags)
 
void fpt_trafo (fpt_set set, const int m, const fftw_complex *x, fftw_complex *y, const int k_end, const unsigned int flags)
 
void fpt_transposed_direct (fpt_set set, const int m, fftw_complex *x, fftw_complex *y, const int k_end, const unsigned int flags)
 
void fpt_transposed (fpt_set set, const int m, fftw_complex *x, fftw_complex *y, const int k_end, const unsigned int flags)
 
void fpt_finalize (fpt_set set)
 
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)
 
void nfsoft_precompute (nfsoft_plan *plan)
 
fpt_set nfsoft_SO3_single_fpt_init (int l, int k, int m, unsigned int flags, int kappa)
 
void nfsoft_SO3_fpt (fftw_complex *coeffs, fpt_set set, int l, int k, int m, unsigned int nfsoft_flags)
 
void nfsoft_SO3_fpt_transposed (fftw_complex *coeffs, fpt_set set, int l, int k, int m, unsigned int nfsoft_flags)
 
void nfsoft_init (nfsoft_plan *plan, int N, int M)
 
void nfsoft_init_advanced (nfsoft_plan *plan, int N, int M, unsigned int nfsoft_flags)
 
void nfsoft_init_guru (nfsoft_plan *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa)
 
void nfsoft_init_guru_advanced (nfsoft_plan *plan, int N, int M, unsigned int nfsoft_flags, unsigned int nfft_flags, int nfft_cutoff, int fpt_kappa, int nn_oversampled)
 
void nfsoft_trafo (nfsoft_plan *plan_nfsoft)
 
void nfsoft_adjoint (nfsoft_plan *plan_nfsoft)
 
void nfsoft_finalize (nfsoft_plan *plan)
 
int nfsoft_posN (int n, int m, int B)
 
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)
 
void solver_init_advanced_complex (solver_plan_complex *ths, nfft_mv_plan_complex *mv, unsigned flags)
 
void solver_init_complex (solver_plan_complex *ths, nfft_mv_plan_complex *mv)
 
void solver_before_loop_complex (solver_plan_complex *ths)
 
void solver_loop_one_step_complex (solver_plan_complex *ths)
 
void solver_finalize_complex (solver_plan_complex *ths)
 
void solver_init_advanced_double (solver_plan_double *ths, nfft_mv_plan_double *mv, unsigned flags)
 
void solver_init_double (solver_plan_double *ths, nfft_mv_plan_double *mv)
 
void solver_before_loop_double (solver_plan_double *ths)
 
void solver_loop_one_step_double (solver_plan_double *ths)
 
void solver_finalize_double (solver_plan_double *ths)
 
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}$.
 
void nfftf_vrand_shifted_unit_double (float *x, const NFFT_INT n)
 Inits a vector of random double numbers in $[-1/2,1/2]$.
 
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 ()
 
double nfft_drand48 (void)
 
void nfft_srand48 (long int seed)
 
void nfft_vrand_unit_complex (fftw_complex *x, const NFFT_INT n)
 Inits a vector of random complex numbers in $[0,1]\times[0,1]{\rm i}$.
 
void nfft_vrand_shifted_unit_double (double *x, const NFFT_INT n)
 Inits a vector of random double numbers in $[-1/2,1/2]$.
 
void nfft_vrand_real (double *x, const NFFT_INT n, const double a, const double b)
 
void nfft_vpr_double (double *x, const NFFT_INT n, const char *text)
 Print real vector to standard output.
 
void nfft_vpr_complex (fftw_complex *x, const NFFT_INT n, const char *text)
 Print complex vector to standard output.
 
NFFT_INT nfft_get_num_threads (void)
 
void nfft_set_num_threads (NFFT_INT nthreads)
 
NFFT_INT nfft_has_threads_enabled (void)
 
double nfft_clock_gettime_seconds (void)
 
double nfft_error_l_infty_complex (const fftw_complex *x, const fftw_complex *y, const NFFT_INT n)
 
double nfft_error_l_infty_1_complex (const fftw_complex *x, const fftw_complex *y, const NFFT_INT n, const fftw_complex *z, const NFFT_INT m)
 
NFFT_INT nfft_exp2i (const NFFT_INT a)
 
NFFT_INT nfft_next_power_of_2 (const NFFT_INT N)
 
double nfft_dot_complex (fftw_complex *x, NFFT_INT n)
 Computes the inner/dot product $x^H x$.
 
void nfft_upd_axpy_complex (fftw_complex *x, double a, fftw_complex *y, NFFT_INT n)
 Updates $x \leftarrow a x + y$.
 
void nfft_fftshift_complex (fftw_complex *x, NFFT_INT d, NFFT_INT *N)
 Swaps each half over N[d]/2.
 
void nfft_fftshift_complex_int (fftw_complex *x, int d, int *N)
 
void nfft_get_version (unsigned *major, unsigned *minor, unsigned *patch)
 Return library version.
 
const char * nfft_get_window_name ()
 
NFFT_INT nfft_get_default_window_cut_off ()
 
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}$.
 
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]$.
 
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
 
nfft_malloc_type_function nfft_malloc_hook
 
nfft_free_type_function nfft_free_hook
 
nfft_die_type_function nfft_die_hook
 
nfftl_malloc_type_function nfftl_malloc_hook
 
nfftl_free_type_function nfftl_free_hook
 
nfftl_die_type_function nfftl_die_hook
 
 nfftf_plan
 
 nfft_plan
 
 nfftl_plan
 

Detailed Description

Header file for the nfft3 library.

Header file for NFFT3

Definition in file nfft3.h.

Macro Definition Documentation

◆ NFFT_CONCAT

#define NFFT_CONCAT (   prefix,
  name 
)    prefix ## name

Definition at line 30 of file nfft3.h.

◆ NFFT_EXTERN

#define NFFT_EXTERN   extern

Definition at line 46 of file nfft3.h.

◆ 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_MANGLE_DOUBLE

#define NFFT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nfft_, name)

Definition at line 71 of file nfft3.h.

◆ NFFT_MANGLE_FLOAT

#define NFFT_MANGLE_FLOAT (   name)    NFFT_CONCAT(nfftf_, name)

Definition at line 72 of file nfft3.h.

◆ NFFT_MANGLE_LONG_DOUBLE

#define NFFT_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(nfftl_, name)

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

◆ NFFT_DEFINE_API

#define NFFT_DEFINE_API (   X,
  Y,
  R,
 
)

Definition at line 102 of file nfft3.h.

◆ NFFT_SORT_NODES

#define NFFT_SORT_NODES   (1U<<11)

Definition at line 198 of file nfft3.h.

◆ NFFT_OMP_BLOCKWISE_ADJOINT

#define NFFT_OMP_BLOCKWISE_ADJOINT   (1U<<12)

Definition at line 199 of file nfft3.h.

◆ NFCT_MANGLE_DOUBLE

#define NFCT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nfct_, name)

Definition at line 205 of file nfft3.h.

◆ NFCT_MANGLE_FLOAT

#define NFCT_MANGLE_FLOAT (   name)    NFFT_CONCAT(nfctf_, name)

Definition at line 206 of file nfft3.h.

◆ NFCT_MANGLE_LONG_DOUBLE

#define NFCT_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(nfctl_, name)

Definition at line 207 of file nfft3.h.

◆ NFCT_DEFINE_API

#define NFCT_DEFINE_API (   X,
  Y,
  R,
 
)

Definition at line 216 of file nfft3.h.

◆ NFST_MANGLE_DOUBLE

#define NFST_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nfst_, name)

Definition at line 284 of file nfft3.h.

◆ NFST_MANGLE_FLOAT

#define NFST_MANGLE_FLOAT (   name)    NFFT_CONCAT(nfstf_, name)

Definition at line 285 of file nfft3.h.

◆ NFST_MANGLE_LONG_DOUBLE

#define NFST_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(nfstl_, name)

Definition at line 286 of file nfft3.h.

◆ NFST_DEFINE_API

#define NFST_DEFINE_API (   X,
  Y,
  R,
 
)

Definition at line 295 of file nfft3.h.

◆ NNFFT_MANGLE_DOUBLE

#define NNFFT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nnfft_, name)

Definition at line 365 of file nfft3.h.

◆ NNFFT_MANGLE_FLOAT

#define NNFFT_MANGLE_FLOAT (   name)    NFFT_CONCAT(nnfftf_, name)

Definition at line 366 of file nfft3.h.

◆ NNFFT_MANGLE_LONG_DOUBLE

#define NNFFT_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(nnfftl_, name)

Definition at line 367 of file nfft3.h.

◆ NNFFT_DEFINE_API

#define NNFFT_DEFINE_API (   X,
  Y,
  Z,
  R,
 
)

Definition at line 377 of file nfft3.h.

◆ NSFFT_MANGLE_DOUBLE

#define NSFFT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nsfft_, name)

Definition at line 433 of file nfft3.h.

◆ NSFFT_MANGLE_FLOAT

#define NSFFT_MANGLE_FLOAT (   name)    NFFT_CONCAT(nsfftf_, name)

Definition at line 434 of file nfft3.h.

◆ NSFFT_MANGLE_LONG_DOUBLE

#define NSFFT_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(nsfftl_, name)

Definition at line 435 of file nfft3.h.

◆ NSFFT_DEFINE_API

#define NSFFT_DEFINE_API (   X,
  Y,
  Z,
  R,
 
)

Definition at line 445 of file nfft3.h.

◆ MRI_MANGLE_DOUBLE

#define MRI_MANGLE_DOUBLE (   name)    NFFT_CONCAT(mri_, name)

Definition at line 487 of file nfft3.h.

◆ MRI_MANGLE_FLOAT

#define MRI_MANGLE_FLOAT (   name)    NFFT_CONCAT(mrif_, name)

Definition at line 488 of file nfft3.h.

◆ MRI_MANGLE_LONG_DOUBLE

#define MRI_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(mril_, name)

Definition at line 489 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 498 of file nfft3.h.

◆ NFSFT_MANGLE_DOUBLE

#define NFSFT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nfsft_, name)

Definition at line 538 of file nfft3.h.

◆ NFSFT_MANGLE_FLOAT

#define NFSFT_MANGLE_FLOAT (   name)    NFFT_CONCAT(nfsftf_, name)

Definition at line 539 of file nfft3.h.

◆ NFSFT_MANGLE_LONG_DOUBLE

#define NFSFT_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(nfsftl_, name)

Definition at line 540 of file nfft3.h.

◆ NFSFT_DEFINE_API

#define NFSFT_DEFINE_API (   X,
  Z,
  R,
 
)

Definition at line 549 of file nfft3.h.

◆ FPT_MANGLE_DOUBLE

#define FPT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(fpt_, name)

Definition at line 611 of file nfft3.h.

◆ FPT_MANGLE_FLOAT

#define FPT_MANGLE_FLOAT (   name)    NFFT_CONCAT(fptf_, name)

Definition at line 612 of file nfft3.h.

◆ FPT_MANGLE_LONG_DOUBLE

#define FPT_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(fptl_, name)

Definition at line 613 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 621 of file nfft3.h.

◆ FPT_NO_INIT_FPT_DATA

#define FPT_NO_INIT_FPT_DATA   (1U << 7)

Definition at line 647 of file nfft3.h.

◆ NFSOFT_MANGLE_DOUBLE

#define NFSOFT_MANGLE_DOUBLE (   name)    NFFT_CONCAT(nfsoft_, name)

Definition at line 656 of file nfft3.h.

◆ NFSOFT_MANGLE_FLOAT

#define NFSOFT_MANGLE_FLOAT (   name)    NFFT_CONCAT(nfsoftf_, name)

Definition at line 657 of file nfft3.h.

◆ NFSOFT_MANGLE_LONG_DOUBLE

#define NFSOFT_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(nfsoftl_, name)

Definition at line 658 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 668 of file nfft3.h.

◆ SOLVER_MANGLE_DOUBLE

#define SOLVER_MANGLE_DOUBLE (   name)    NFFT_CONCAT(solver_, name)

Definition at line 730 of file nfft3.h.

◆ SOLVER_MANGLE_FLOAT

#define SOLVER_MANGLE_FLOAT (   name)    NFFT_CONCAT(solverf_, name)

Definition at line 731 of file nfft3.h.

◆ SOLVER_MANGLE_LONG_DOUBLE

#define SOLVER_MANGLE_LONG_DOUBLE (   name)    NFFT_CONCAT(solverl_, name)

Definition at line 732 of file nfft3.h.

◆ SOLVER_DEFINE_API

#define SOLVER_DEFINE_API (   X,
  Y,
  R,
 
)

Definition at line 741 of file nfft3.h.

◆ NFFT_DEFINE_UTIL_API

#define NFFT_DEFINE_UTIL_API (   Y,
  R,
 
)

Definition at line 822 of file nfft3.h.

Typedef Documentation

◆ NFFT_INT

typedef ptrdiff_t NFFT_INT

Definition at line 51 of file nfft3.h.

◆ nfftf_malloc_type_function

typedef void *(* nfftf_malloc_type_function) (size_t n)

Definition at line 91 of file nfft3.h.

◆ nfftf_free_type_function

typedef void(* nfftf_free_type_function) (void *p)

Definition at line 91 of file nfft3.h.

◆ nfftf_die_type_function

typedef void(* nfftf_die_type_function) (const char *errString)

Definition at line 91 of file nfft3.h.

◆ nfft_malloc_type_function

typedef void *(* nfft_malloc_type_function)(size_t n)

A malloc type function

Definition at line 92 of file nfft3.h.

◆ nfft_free_type_function

typedef void(* nfft_free_type_function)(void *p)

A free type function

Definition at line 92 of file nfft3.h.

◆ nfft_die_type_function

typedef void(* nfft_die_type_function) (const char *errString)

Definition at line 92 of file nfft3.h.

◆ nfftl_malloc_type_function

typedef void *(* nfftl_malloc_type_function) (size_t n)

Definition at line 93 of file nfft3.h.

◆ nfftl_free_type_function

typedef void(* nfftl_free_type_function) (void *p)

Definition at line 93 of file nfft3.h.

◆ nfftl_die_type_function

typedef void(* nfftl_die_type_function) (const char *errString)

Definition at line 93 of file nfft3.h.

◆ fptf_set

typedef struct fptf_set_s_* fptf_set

A set of precomputed data for a set of DPT transforms of equal maximum length.

Definition at line 638 of file nfft3.h.

◆ fpt_set

typedef struct fpt_set_s_* fpt_set

A set of precomputed data for a set of DPT transforms of equal maximum length.

Definition at line 639 of file nfft3.h.

◆ fptl_set

typedef struct fptl_set_s_* fptl_set

A set of precomputed data for a set of DPT transforms of equal maximum length.

Definition at line 640 of file nfft3.h.

Function Documentation

◆ nfft_malloc()

void * nfft_malloc ( size_t  n)
extern

Our malloc function

Parameters
nThe number of bytes to allocate

Referenced by main(), nfsft_precompute(), nnfft_precompute_phi_hut(), and reconstruct().

◆ nfft_free()

void nfft_free ( void *  p)
extern

Our free function

Parameters
pPointer to the memory region to free

Referenced by main(), nfsft_finalize(), nfsft_forget(), nfsft_precompute(), and reconstruct().

◆ __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

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

Definition at line 93 of file nfft3.h.

◆ nnfft_init()

void nnfft_init ( nnfft_plan ths_plan,
int  d,
int  N_total,
int  M_total,
int *  N 
)
extern

Definition at line 613 of file nnfft.c.

◆ nnfft_init_1d()

void nnfft_init_1d ( nnfft_plan ths_plan,
int  N,
int  M_total 
)
extern

Definition at line 652 of file nnfft.c.

◆ nnfft_init_guru()

void nnfft_init_guru ( nnfft_plan ths_plan,
int  d,
int  N_total,
int  M_total,
int *  N,
int *  N1,
int  m,
unsigned  nnfft_flags 
)
extern

Definition at line 577 of file nnfft.c.

◆ nnfft_trafo_direct()

void nnfft_trafo_direct ( nnfft_plan ths_plan)
extern

Definition at line 81 of file nnfft.c.

◆ nnfft_adjoint_direct()

void nnfft_adjoint_direct ( nnfft_plan ths_plan)
extern

Definition at line 82 of file nnfft.c.

◆ nnfft_trafo()

void nnfft_trafo ( nnfft_plan ths_plan)
extern

user routines

Definition at line 291 of file nnfft.c.

References nnfft_plan::d, nnfft_plan::direct_plan, nnfft_plan::f, nnfft_plan::M_total, nnfft_trafo(), nnfft_plan::sigma, and nnfft_plan::x.

Referenced by nnfft_trafo().

◆ nnfft_adjoint()

void nnfft_adjoint ( nnfft_plan ths_plan)
extern

Definition at line 319 of file nnfft.c.

◆ nnfft_precompute_lin_psi()

void nnfft_precompute_lin_psi ( nnfft_plan ths_plan)
extern

◆ nnfft_precompute_psi()

void nnfft_precompute_psi ( nnfft_plan ths_plan)
extern

Definition at line 385 of file nnfft.c.

◆ nnfft_precompute_full_psi()

void nnfft_precompute_full_psi ( nnfft_plan ths_plan)
extern

◆ nnfft_precompute_phi_hut()

void nnfft_precompute_phi_hut ( nnfft_plan ths_plan)
extern

◆ nnfft_precompute_one_psi()

void nnfft_precompute_one_psi ( nnfft_plan ths)
extern

Definition at line 481 of file nnfft.c.

◆ nnfft_finalize()

void nnfft_finalize ( nnfft_plan ths_plan)
extern

Definition at line 657 of file nnfft.c.

◆ nsfft_trafo_direct()

void nsfft_trafo_direct ( nsfft_plan ths)
extern

Definition at line 812 of file nsfft.c.

◆ nsfft_adjoint_direct()

void nsfft_adjoint_direct ( nsfft_plan ths)
extern

Definition at line 872 of file nsfft.c.

◆ nsfft_trafo()

void nsfft_trafo ( nsfft_plan ths)
extern

Definition at line 1541 of file nsfft.c.

◆ nsfft_adjoint()

void nsfft_adjoint ( nsfft_plan ths)
extern

Definition at line 1549 of file nsfft.c.

◆ nsfft_cp()

void nsfft_cp ( nsfft_plan ths,
nfft_plan ths_nfft 
)
extern

Definition at line 599 of file nsfft.c.

◆ nsfft_init_random_nodes_coeffs()

void nsfft_init_random_nodes_coeffs ( nsfft_plan ths)
extern

Definition at line 723 of file nsfft.c.

◆ nsfft_init()

void nsfft_init ( nsfft_plan ths,
int  d,
int  J,
int  M,
int  m,
unsigned  flags 
)
extern

Definition at line 1778 of file nsfft.c.

◆ nsfft_finalize()

void nsfft_finalize ( nsfft_plan ths)
extern

Definition at line 1885 of file nsfft.c.

◆ mri_inh_2d1d_trafo()

void mri_inh_2d1d_trafo ( mri_inh_2d1d_plan ths)

Definition at line 57 of file mri.c.

◆ mri_inh_2d1d_adjoint()

void mri_inh_2d1d_adjoint ( mri_inh_2d1d_plan ths)

Definition at line 104 of file mri.c.

◆ mri_inh_2d1d_init_guru()

void mri_inh_2d1d_init_guru ( mri_inh_2d1d_plan ths,
int *  N,
int  M,
int *  n,
int  m,
double  sigma,
unsigned  nfft_flags,
unsigned  fftw_flags 
)

Definition at line 156 of file mri.c.

◆ mri_inh_2d1d_finalize()

void mri_inh_2d1d_finalize ( mri_inh_2d1d_plan ths)

Definition at line 174 of file mri.c.

◆ mri_inh_3d_trafo()

void mri_inh_3d_trafo ( mri_inh_3d_plan ths)

Definition at line 189 of file mri.c.

◆ mri_inh_3d_adjoint()

void mri_inh_3d_adjoint ( mri_inh_3d_plan ths)

Definition at line 221 of file mri.c.

◆ mri_inh_3d_init_guru()

void mri_inh_3d_init_guru ( mri_inh_3d_plan ths,
int *  N,
int  M,
int *  n,
int  m,
double  sigma,
unsigned  nfft_flags,
unsigned  fftw_flags 
)

Definition at line 251 of file mri.c.

◆ mri_inh_3d_finalize()

void mri_inh_3d_finalize ( mri_inh_3d_plan ths)

Definition at line 266 of file mri.c.

◆ fpt_init()

fpt_set fpt_init ( const int  M,
const int  t,
const unsigned int  flags 
)
extern

Definition at line 795 of file fpt.c.

◆ fpt_precompute()

void fpt_precompute ( fpt_set  set,
const int  m,
double *  alpha,
double *  beta,
double *  gam,
int  k_start,
const double  threshold 
)
extern

Definition at line 1307 of file fpt.c.

◆ fpt_finalize()

void fpt_finalize ( fpt_set  set)
extern

Definition at line 1979 of file fpt.c.

◆ nfsoft_precompute()

void nfsoft_precompute ( nfsoft_plan plan)
extern

Definition at line 382 of file nfsoft.c.

◆ nfsoft_init()

void nfsoft_init ( nfsoft_plan plan,
int  N,
int  M 
)
extern

Definition at line 45 of file nfsoft.c.

◆ nfsoft_init_advanced()

void nfsoft_init_advanced ( nfsoft_plan plan,
int  N,
int  M,
unsigned int  nfsoft_flags 
)
extern

Definition at line 51 of file nfsoft.c.

◆ nfsoft_init_guru()

void nfsoft_init_guru ( nfsoft_plan plan,
int  N,
int  M,
unsigned int  nfsoft_flags,
unsigned int  nfft_flags,
int  nfft_cutoff,
int  fpt_kappa 
)
extern

Definition at line 59 of file nfsoft.c.

◆ nfsoft_init_guru_advanced()

void nfsoft_init_guru_advanced ( nfsoft_plan plan,
int  N,
int  M,
unsigned int  nfsoft_flags,
unsigned int  nfft_flags,
int  nfft_cutoff,
int  fpt_kappa,
int  nn_oversampled 
)
extern

Definition at line 66 of file nfsoft.c.

◆ nfsoft_trafo()

void nfsoft_trafo ( nfsoft_plan plan_nfsoft)
extern

Definition at line 416 of file nfsoft.c.

◆ nfsoft_adjoint()

void nfsoft_adjoint ( nfsoft_plan plan_nfsoft)
extern

Definition at line 545 of file nfsoft.c.

◆ nfsoft_finalize()

void nfsoft_finalize ( nfsoft_plan plan)
extern

Definition at line 645 of file nfsoft.c.

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

◆ nfft_vrand_unit_complex()

void nfft_vrand_unit_complex ( fftw_complex *  x,
const NFFT_INT  n 
)

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


◆ nfft_vrand_shifted_unit_double()

void nfft_vrand_shifted_unit_double ( double *  x,
const NFFT_INT  n 
)

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


◆ nfft_get_window_name()

const char * nfft_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.

Variable Documentation

◆ nfft_malloc_hook

nfft_malloc_type_function nfft_malloc_hook
extern

Hook for nfft_malloc

◆ nfft_free_hook

nfft_free_type_function nfft_free_hook
extern

Hook for nfft_free

◆ nfftf_plan

nfftf_plan

Definition at line 182 of file nfft3.h.

◆ nfft_plan

Definition at line 183 of file nfft3.h.

◆ nfftl_plan

nfftl_plan

Definition at line 184 of file nfft3.h.