NFFT 3.5.3alpha
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)
#define NFFT_EXTERN   extern
#define MACRO_MV_PLAN(RC)
 Adjoint transform.
#define NFFT_MANGLE_DOUBLE(name)
#define NFFT_MANGLE_FLOAT(name)
#define NFFT_MANGLE_LONG_DOUBLE(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)
#define NFCT_MANGLE_FLOAT(name)
#define NFCT_MANGLE_LONG_DOUBLE(name)
#define NFCT_DEFINE_API(X, Y, R, C)
#define NFST_MANGLE_DOUBLE(name)
#define NFST_MANGLE_FLOAT(name)
#define NFST_MANGLE_LONG_DOUBLE(name)
#define NFST_DEFINE_API(X, Y, R, C)
#define NNFFT_MANGLE_DOUBLE(name)
#define NNFFT_MANGLE_FLOAT(name)
#define NNFFT_MANGLE_LONG_DOUBLE(name)
#define NNFFT_DEFINE_API(X, Y, Z, R, C)
#define MALLOC_V   (1U<< 11)
#define NSFFT_MANGLE_DOUBLE(name)
#define NSFFT_MANGLE_FLOAT(name)
#define NSFFT_MANGLE_LONG_DOUBLE(name)
#define NSFFT_DEFINE_API(X, Y, Z, R, C)
#define NSDFT   (1U<< 12)
#define MRI_MANGLE_DOUBLE(name)
#define MRI_MANGLE_FLOAT(name)
#define MRI_MANGLE_LONG_DOUBLE(name)
#define MRI_DEFINE_API(X, Z, R, C)
#define NFSFT_MANGLE_DOUBLE(name)
#define NFSFT_MANGLE_FLOAT(name)
#define NFSFT_MANGLE_LONG_DOUBLE(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)
#define NFSFT_F_HAT_SIZE(N)
#define FPT_MANGLE_DOUBLE(name)
#define FPT_MANGLE_FLOAT(name)
#define FPT_MANGLE_LONG_DOUBLE(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)
#define NFSOFT_MANGLE_FLOAT(name)
#define NFSOFT_MANGLE_LONG_DOUBLE(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)
#define NFSOFT_F_HAT_SIZE(B)
#define SOLVER_MANGLE_DOUBLE(name)
#define SOLVER_MANGLE_FLOAT(name)
#define SOLVER_MANGLE_LONG_DOUBLE(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 )
Value:
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 54 of file nfft3.h.

◆ NFFT_MANGLE_DOUBLE

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

Definition at line 65 of file nfft3.h.

◆ NFFT_MANGLE_FLOAT

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

Definition at line 66 of file nfft3.h.

◆ NFFT_MANGLE_LONG_DOUBLE

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

Definition at line 67 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);
#define X(name)
Include header for C99 complex datatype.
Definition fastsum.h:57

Definition at line 69 of file nfft3.h.

◆ NFFT_DEFINE_API

#define NFFT_DEFINE_API ( X,
Y,
R,
C )

Definition at line 96 of file nfft3.h.

◆ NFFT_SORT_NODES

#define NFFT_SORT_NODES   (1U<<11)

Definition at line 192 of file nfft3.h.

◆ NFFT_OMP_BLOCKWISE_ADJOINT

#define NFFT_OMP_BLOCKWISE_ADJOINT   (1U<<12)

Definition at line 193 of file nfft3.h.

◆ NFCT_MANGLE_DOUBLE

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

Definition at line 199 of file nfft3.h.

◆ NFCT_MANGLE_FLOAT

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

Definition at line 200 of file nfft3.h.

◆ NFCT_MANGLE_LONG_DOUBLE

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

Definition at line 201 of file nfft3.h.

◆ NFCT_DEFINE_API

#define NFCT_DEFINE_API ( X,
Y,
R,
C )

Definition at line 210 of file nfft3.h.

◆ NFST_MANGLE_DOUBLE

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

Definition at line 278 of file nfft3.h.

◆ NFST_MANGLE_FLOAT

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

Definition at line 279 of file nfft3.h.

◆ NFST_MANGLE_LONG_DOUBLE

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

Definition at line 280 of file nfft3.h.

◆ NFST_DEFINE_API

#define NFST_DEFINE_API ( X,
Y,
R,
C )

Definition at line 289 of file nfft3.h.

◆ NNFFT_MANGLE_DOUBLE

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

Definition at line 359 of file nfft3.h.

◆ NNFFT_MANGLE_FLOAT

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

Definition at line 360 of file nfft3.h.

◆ NNFFT_MANGLE_LONG_DOUBLE

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

Definition at line 361 of file nfft3.h.

◆ NNFFT_DEFINE_API

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

Definition at line 371 of file nfft3.h.

◆ NSFFT_MANGLE_DOUBLE

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

Definition at line 427 of file nfft3.h.

◆ NSFFT_MANGLE_FLOAT

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

Definition at line 428 of file nfft3.h.

◆ NSFFT_MANGLE_LONG_DOUBLE

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

Definition at line 429 of file nfft3.h.

◆ NSFFT_DEFINE_API

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

Definition at line 439 of file nfft3.h.

◆ MRI_MANGLE_DOUBLE

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

Definition at line 481 of file nfft3.h.

◆ MRI_MANGLE_FLOAT

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

Definition at line 482 of file nfft3.h.

◆ MRI_MANGLE_LONG_DOUBLE

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

Definition at line 483 of file nfft3.h.

◆ MRI_DEFINE_API

#define MRI_DEFINE_API ( X,
Z,
R,
C )
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 492 of file nfft3.h.

◆ NFSFT_MANGLE_DOUBLE

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

Definition at line 532 of file nfft3.h.

◆ NFSFT_MANGLE_FLOAT

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

Definition at line 533 of file nfft3.h.

◆ NFSFT_MANGLE_LONG_DOUBLE

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

Definition at line 534 of file nfft3.h.

◆ NFSFT_DEFINE_API

#define NFSFT_DEFINE_API ( X,
Z,
R,
C )

Definition at line 543 of file nfft3.h.

◆ FPT_MANGLE_DOUBLE

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

Definition at line 605 of file nfft3.h.

◆ FPT_MANGLE_FLOAT

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

Definition at line 606 of file nfft3.h.

◆ FPT_MANGLE_LONG_DOUBLE

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

Definition at line 607 of file nfft3.h.

◆ FPT_DEFINE_API

#define FPT_DEFINE_API ( X,
Y,
R,
C )
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 615 of file nfft3.h.

◆ FPT_NO_INIT_FPT_DATA

#define FPT_NO_INIT_FPT_DATA   (1U << 7)

Definition at line 641 of file nfft3.h.

◆ NFSOFT_MANGLE_DOUBLE

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

Definition at line 650 of file nfft3.h.

◆ NFSOFT_MANGLE_FLOAT

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

Definition at line 651 of file nfft3.h.

◆ NFSOFT_MANGLE_LONG_DOUBLE

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

Definition at line 652 of file nfft3.h.

◆ NFSOFT_DEFINE_API

#define NFSOFT_DEFINE_API ( X,
Y,
Z,
R,
C )
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 662 of file nfft3.h.

◆ SOLVER_MANGLE_DOUBLE

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

Definition at line 724 of file nfft3.h.

◆ SOLVER_MANGLE_FLOAT

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

Definition at line 725 of file nfft3.h.

◆ SOLVER_MANGLE_LONG_DOUBLE

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

Definition at line 726 of file nfft3.h.

◆ SOLVER_DEFINE_API

#define SOLVER_DEFINE_API ( X,
Y,
R,
C )

Definition at line 735 of file nfft3.h.

◆ NFFT_DEFINE_UTIL_API

#define NFFT_DEFINE_UTIL_API ( Y,
R,
C )

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

◆ nfftf_free_type_function

typedef void(* nfftf_free_type_function) (void *p)

Definition at line 85 of file nfft3.h.

◆ nfftf_die_type_function

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

Definition at line 85 of file nfft3.h.

◆ nfft_malloc_type_function

typedef void *(* nfft_malloc_type_function) (size_t n)

A malloc type function

Definition at line 86 of file nfft3.h.

◆ nfft_free_type_function

typedef void(* nfft_free_type_function) (void *p)

A free type function

Definition at line 86 of file nfft3.h.

◆ nfft_die_type_function

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

Definition at line 86 of file nfft3.h.

◆ nfftl_malloc_type_function

typedef void *(* nfftl_malloc_type_function) (size_t n)

Definition at line 87 of file nfft3.h.

◆ nfftl_free_type_function

typedef void(* nfftl_free_type_function) (void *p)

Definition at line 87 of file nfft3.h.

◆ nfftl_die_type_function

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

Definition at line 87 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 632 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 633 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 634 of file nfft3.h.

Function Documentation

◆ nfft_malloc()

void * nfft_malloc ( size_t n)
extern

◆ nfft_free()

void nfft_free ( void * p)
extern

◆ __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 87 of file nfft3.h.

◆ 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_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_precompute_one_psi()

void nnfft_precompute_one_psi ( nnfft_plan * ths)
extern

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

◆ mri_inh_2d1d_adjoint()

void mri_inh_2d1d_adjoint ( mri_inh_2d1d_plan * ths)

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

◆ fpt_finalize()

void fpt_finalize ( fpt_set set)
extern

Definition at line 1979 of file fpt.c.

◆ 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_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_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 176 of file nfft3.h.

◆ nfft_plan

nfft_plan

Definition at line 177 of file nfft3.h.

◆ nfftl_plan

nfftl_plan

Definition at line 178 of file nfft3.h.