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 .
void | nfftf_vrand_shifted_unit_double (float *x, const NFFT_INT n)
| Inits a vector of random double numbers in .
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 .
void | nfftf_upd_axpy_complex (fftwf_complex *x, float a, fftwf_complex *y, NFFT_INT n)
| Updates .
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 .
void | nfft_vrand_shifted_unit_double (double *x, const NFFT_INT n)
| Inits a vector of random double numbers in .
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 .
void | nfft_upd_axpy_complex (fftw_complex *x, double a, fftw_complex *y, NFFT_INT n)
| Updates .
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 .
void | nfftl_vrand_shifted_unit_double (long double *x, const NFFT_INT n)
| Inits a vector of random double numbers in .
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 .
void | nfftl_upd_axpy_complex (fftwl_complex *x, long double a, fftwl_complex *y, NFFT_INT n)
| Updates .
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);
X
#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

Our `malloc` function

Parameters

  n | The number of bytes to allocate

Referenced by fpt_init(), main(), mri_inh_2d1d_init_guru(), mri_inh_2d1d_trafo(), mri_inh_3d_adjoint(), mri_inh_3d_trafo(), nfsft_precompute(), nfsoft_init_guru_advanced(), nnfft_init(), nnfft_init_guru(), nnfft_precompute_phi_hut(), and reconstruct().

## nfft_free()

void nfft_free | ( | void * | p | ) |

extern

Our `free` function

Parameters

  p | Pointer to the memory region to free

Referenced by fpt_init(), main(), mri_inh_2d1d_finalize(), mri_inh_2d1d_trafo(), mri_inh_3d_adjoint(), mri_inh_3d_finalize(), mri_inh_3d_trafo(), nfsft_finalize(), nfsft_forget(), nfsft_precompute(), nfsoft_finalize(), nnfft_finalize(), 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 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.