pocketfft.h File Reference

#include <cmath>
#include <cstdlib>
#include <stdexcept>
#include <memory>
#include <vector>
#include <complex>
#include <algorithm>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <queue>
#include <atomic>
#include <functional>
#include <new>

Go to the source code of this file.

Classes
struct	pocketfft::detail::VLEN< T >
class	pocketfft::detail::arr< T >
struct	pocketfft::detail::cmplx< T >
class	pocketfft::detail::sincos_2pibyn< T >
struct	pocketfft::detail::util
class	pocketfft::detail::threading::latch
class	pocketfft::detail::threading::concurrent_queue< T >
struct	pocketfft::detail::threading::aligned_allocator< T >
class	pocketfft::detail::threading::thread_pool
class	pocketfft::detail::cfftp< T0 >
class	pocketfft::detail::rfftp< T0 >
class	pocketfft::detail::fftblue< T0 >
class	pocketfft::detail::pocketfft_c< T0 >
class	pocketfft::detail::pocketfft_r< T0 >
class	pocketfft::detail::T_dct1< T0 >
class	pocketfft::detail::T_dst1< T0 >
class	pocketfft::detail::T_dcst23< T0 >
class	pocketfft::detail::T_dcst4< T0 >
class	pocketfft::detail::arr_info
class	pocketfft::detail::cndarr< T >
class	pocketfft::detail::ndarr< T >
class	pocketfft::detail::multi_iter< N >
class	pocketfft::detail::simple_iter
class	pocketfft::detail::rev_iter
struct	pocketfft::detail::VTYPE< T >
struct	pocketfft::detail::add_vec< T >
struct	pocketfft::detail::add_vec< cmplx< T > >
struct	pocketfft::detail::ExecC2C
struct	pocketfft::detail::ExecHartley
struct	pocketfft::detail::ExecDcst
struct	pocketfft::detail::ExecR2R

Namespaces
namespace	pocketfft
namespace	pocketfft::detail
namespace	pocketfft::detail::threading

Macros
#define	POCKETFFT_CACHE_SIZE   0
#define	POCKETFFT_NOINLINE
#define	POCKETFFT_RESTRICT
#define	POCKETFFT_NO_VECTORS
#define	POCKETFFT_PREP3(idx)
#define	POCKETFFT_PARTSTEP3a(u1, u2, twr, twi)
#define	POCKETFFT_PARTSTEP3b(u1, u2, twr, twi)
#define	POCKETFFT_PREP5(idx)
#define	POCKETFFT_PARTSTEP5a(u1, u2, twar, twbr, twai, twbi)
#define	POCKETFFT_PARTSTEP5b(u1, u2, twar, twbr, twai, twbi)
#define	POCKETFFT_PREP7(idx)
#define	POCKETFFT_PARTSTEP7a0(u1, u2, x1, x2, x3, y1, y2, y3, out1, out2)
#define	POCKETFFT_PARTSTEP7a(u1, u2, x1, x2, x3, y1, y2, y3)
#define	POCKETFFT_PARTSTEP7(u1, u2, x1, x2, x3, y1, y2, y3)
#define	POCKETFFT_PREP11(idx)
#define	POCKETFFT_PARTSTEP11a0(u1, u2, x1, x2, x3, x4, x5, y1, y2, y3, y4, y5, out1, out2)
#define	POCKETFFT_PARTSTEP11a(u1, u2, x1, x2, x3, x4, x5, y1, y2, y3, y4, y5)
#define	POCKETFFT_PARTSTEP11(u1, u2, x1, x2, x3, x4, x5, y1, y2, y3, y4, y5)
#define	POCKETFFT_REARRANGE(rx, ix, ry, iy)

Typedefs
using	pocketfft::detail::shape_t = std::vector<size_t>
using	pocketfft::detail::stride_t = std::vector<ptrdiff_t>
template<typename T>
using	pocketfft::detail::vtype_t = typename VTYPE<T>::type
template<typename T>
using	pocketfft::detail::add_vec_t = typename add_vec<T>::type
using	pocketfft::shape_t
using	pocketfft::stride_t

Functions
template<typename T>
T	pocketfft::detail::cos (T)=delete
template<typename T>
T	pocketfft::detail::sin (T)=delete
template<typename T>
T	pocketfft::detail::sqrt (T)=delete
void *	pocketfft::detail::aligned_alloc (size_t align, size_t size)
void	pocketfft::detail::aligned_dealloc (void *ptr)
template<typename T>
void	pocketfft::detail::PM (T &a, T &b, T c, T d)
template<typename T>
void	pocketfft::detail::PMINPLACE (T &a, T &b)
template<typename T>
void	pocketfft::detail::MPINPLACE (T &a, T &b)
template<typename T>
cmplx< T >	pocketfft::detail::conj (const cmplx< T > &a)
template<bool fwd, typename T, typename T2>
void	pocketfft::detail::special_mul (const cmplx< T > &v1, const cmplx< T2 > &v2, cmplx< T > &res)
template<typename T>
void	pocketfft::detail::ROT90 (cmplx< T > &a)
template<bool fwd, typename T>
void	pocketfft::detail::ROTX90 (cmplx< T > &a)
size_t &	pocketfft::detail::threading::thread_id ()
size_t &	pocketfft::detail::threading::num_threads ()
thread_pool &	pocketfft::detail::threading::get_pool ()
template<typename Func>
void	pocketfft::detail::threading::thread_map (size_t nthreads, Func f)
	Map a function f over nthreads.
template<typename T>
std::shared_ptr< T >	pocketfft::detail::get_plan (size_t length)
template<typename T>
arr< char >	pocketfft::detail::alloc_tmp (const shape_t &shape, size_t axsize, size_t elemsize)
template<typename T>
arr< char >	pocketfft::detail::alloc_tmp (const shape_t &shape, const shape_t &axes, size_t elemsize)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_input (const multi_iter< vlen > &it, const cndarr< cmplx< T > > &src, cmplx< vtype_t< T > > *dst)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_input (const multi_iter< vlen > &it, const cndarr< T > &src, vtype_t< T > *dst)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_input (const multi_iter< vlen > &it, const cndarr< T > &src, T *dst)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_output (const multi_iter< vlen > &it, const cmplx< vtype_t< T > > *src, ndarr< cmplx< T > > &dst)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_output (const multi_iter< vlen > &it, const vtype_t< T > *src, ndarr< T > &dst)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_output (const multi_iter< vlen > &it, const T *src, ndarr< T > &dst)
template<typename Tplan, typename T, typename T0, typename Exec>
void	pocketfft::detail::general_nd (const cndarr< T > &in, ndarr< T > &out, const shape_t &axes, T0 fct, size_t nthreads, const Exec &exec, const bool allow_inplace=true)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_hartley (const multi_iter< vlen > &it, const vtype_t< T > *src, ndarr< T > &dst)
template<typename T, size_t vlen>
void	pocketfft::detail::copy_hartley (const multi_iter< vlen > &it, const T *src, ndarr< T > &dst)
template<typename T>
void	pocketfft::detail::general_r2c (const cndarr< T > &in, ndarr< cmplx< T > > &out, size_t axis, bool forward, T fct, size_t nthreads)
template<typename T>
void	pocketfft::detail::general_c2r (const cndarr< cmplx< T > > &in, ndarr< T > &out, size_t axis, bool forward, T fct, size_t nthreads)
template<typename T>
void	pocketfft::detail::c2c (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, bool forward, const std::complex< T > *data_in, std::complex< T > *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::dct (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::dst (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::r2c (const shape_t &shape_in, const stride_t &stride_in, const stride_t &stride_out, size_t axis, bool forward, const T *data_in, std::complex< T > *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::r2c (const shape_t &shape_in, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, bool forward, const T *data_in, std::complex< T > *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::c2r (const shape_t &shape_out, const stride_t &stride_in, const stride_t &stride_out, size_t axis, bool forward, const std::complex< T > *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::c2r (const shape_t &shape_out, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, bool forward, const std::complex< T > *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::r2r_fftpack (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, bool real2hermitian, bool forward, const T *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::r2r_separable_hartley (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, const T *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::detail::r2r_genuine_hartley (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, const T *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::c2c (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, bool forward, const std::complex< T > *data_in, std::complex< T > *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::c2r (const shape_t &shape_out, const stride_t &stride_in, const stride_t &stride_out, size_t axis, bool forward, const std::complex< T > *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::r2c (const shape_t &shape_in, const stride_t &stride_in, const stride_t &stride_out, size_t axis, bool forward, const T *data_in, std::complex< T > *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::r2r_fftpack (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, bool real2hermitian, bool forward, const T *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::r2r_separable_hartley (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, const T *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::r2r_genuine_hartley (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, const T *data_in, T *data_out, T fct, size_t nthreads=1)
template<typename T>
void	pocketfft::dct (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)
template<typename T>
void	pocketfft::dst (const shape_t &shape, const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes, int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)

Variables
constexpr bool	pocketfft::detail::FORWARD = true
constexpr bool	pocketfft::detail::BACKWARD = false
static const size_t	pocketfft::detail::threading::max_threads = std::max(1u, std::thread::hardware_concurrency())
constexpr bool	pocketfft::FORWARD
constexpr bool	pocketfft::BACKWARD

Macro Definition Documentation

POCKETFFT_CACHE_SIZE

#define POCKETFFT_CACHE_SIZE   0

POCKETFFT_NO_VECTORS

#define POCKETFFT_NO_VECTORS

POCKETFFT_NOINLINE

#define POCKETFFT_NOINLINE

POCKETFFT_PARTSTEP11

#define POCKETFFT_PARTSTEP11	(		u1,
			u2,
			x1,
			x2,
			x3,
			x4,
			x5,
			y1,
			y2,
			y3,
			y4,
			y5 )

Value:

        { \
        T da,db; \
        POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,da,db) \
        special_mul<fwd>(da,WA(u1-1,i),CH(i,k,u1)); \
        special_mul<fwd>(db,WA(u2-1,i),CH(i,k,u2)); \
        }

POCKETFFT_PARTSTEP11a

#define POCKETFFT_PARTSTEP11a	(		u1,
			u2,
			x1,
			x2,
			x3,
			x4,
			x5,
			y1,
			y2,
			y3,
			y4,
			y5 )

Value:

        POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,CH(0,k,u1),CH(0,k,u2))

POCKETFFT_PARTSTEP11a0

#define POCKETFFT_PARTSTEP11a0	(		u1,
			u2,
			x1,
			x2,
			x3,
			x4,
			x5,
			y1,
			y2,
			y3,
			y4,
			y5,
			out1,
			out2 )

Value:

        { \
        T ca = t1 + t2*x1 + t3*x2 + t4*x3 + t5*x4 +t6*x5, \
          cb; \
        cb.i=y1*t11.r y2*t10.r y3*t9.r y4*t8.r y5*t7.r; \
        cb.r=-(y1*t11.i y2*t10.i y3*t9.i y4*t8.i y5*t7.i ); \
        PM(out1,out2,ca,cb); \
        }

POCKETFFT_PARTSTEP3a

#define POCKETFFT_PARTSTEP3a	(		u1,
			u2,
			twr,
			twi )

Value:

        { \
        T ca=t0+t1*twr; \
        T cb{-t2.i*twi, t2.r*twi}; \
        PM(CH(0,k,u1),CH(0,k,u2),ca,cb) ;\
        }

POCKETFFT_PARTSTEP3b

#define POCKETFFT_PARTSTEP3b	(		u1,
			u2,
			twr,
			twi )

Value:

        { \
        T ca=t0+t1*twr; \
        T cb{-t2.i*twi, t2.r*twi}; \
        special_mul<fwd>(ca+cb,WA(u1-1,i),CH(i,k,u1)); \
        special_mul<fwd>(ca-cb,WA(u2-1,i),CH(i,k,u2)); \
        }

POCKETFFT_PARTSTEP5a

#define POCKETFFT_PARTSTEP5a	(		u1,
			u2,
			twar,
			twbr,
			twai,
			twbi )

Value:

        { \
        T ca,cb; \
        ca.r=t0.r+twar*t1.r+twbr*t2.r; \
        ca.i=t0.i+twar*t1.i+twbr*t2.i; \
        cb.i=twai*t4.r twbi*t3.r; \
        cb.r=-(twai*t4.i twbi*t3.i); \
        PM(CH(0,k,u1),CH(0,k,u2),ca,cb); \
        }

POCKETFFT_PARTSTEP5b

#define POCKETFFT_PARTSTEP5b	(		u1,
			u2,
			twar,
			twbr,
			twai,
			twbi )

Value:

        { \
        T ca,cb,da,db; \
        ca.r=t0.r+twar*t1.r+twbr*t2.r; \
        ca.i=t0.i+twar*t1.i+twbr*t2.i; \
        cb.i=twai*t4.r twbi*t3.r; \
        cb.r=-(twai*t4.i twbi*t3.i); \
        special_mul<fwd>(ca+cb,WA(u1-1,i),CH(i,k,u1)); \
        special_mul<fwd>(ca-cb,WA(u2-1,i),CH(i,k,u2)); \
        }

POCKETFFT_PARTSTEP7

#define POCKETFFT_PARTSTEP7	(		u1,
			u2,
			x1,
			x2,
			x3,
			y1,
			y2,
			y3 )

Value:

        { \
        T da,db; \
        POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,da,db) \
        special_mul<fwd>(da,WA(u1-1,i),CH(i,k,u1)); \
        special_mul<fwd>(db,WA(u2-1,i),CH(i,k,u2)); \
        }

POCKETFFT_PARTSTEP7a

#define POCKETFFT_PARTSTEP7a	(		u1,
			u2,
			x1,
			x2,
			x3,
			y1,
			y2,
			y3 )

Value:

        POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,CH(0,k,u1),CH(0,k,u2))

POCKETFFT_PARTSTEP7a0

#define POCKETFFT_PARTSTEP7a0	(		u1,
			u2,
			x1,
			x2,
			x3,
			y1,
			y2,
			y3,
			out1,
			out2 )

Value:

        { \
        T ca,cb; \
        ca.r=t1.r+x1*t2.r+x2*t3.r+x3*t4.r; \
        ca.i=t1.i+x1*t2.i+x2*t3.i+x3*t4.i; \
        cb.i=y1*t7.r y2*t6.r y3*t5.r; \
        cb.r=-(y1*t7.i y2*t6.i y3*t5.i); \
        PM(out1,out2,ca,cb); \
        }

POCKETFFT_PREP11

#define POCKETFFT_PREP11

(

idx

)

Value:

        T t1 = CC(idx,0,k), t2, t3, t4, t5, t6, t7, t8, t9, t10, t11; \
        PM (t2,t11,CC(idx,1,k),CC(idx,10,k)); \
        PM (t3,t10,CC(idx,2,k),CC(idx, 9,k)); \
        PM (t4,t9 ,CC(idx,3,k),CC(idx, 8,k)); \
        PM (t5,t8 ,CC(idx,4,k),CC(idx, 7,k)); \
        PM (t6,t7 ,CC(idx,5,k),CC(idx, 6,k)); \
        CH(idx,k,0).r=t1.r+t2.r+t3.r+t4.r+t5.r+t6.r; \
        CH(idx,k,0).i=t1.i+t2.i+t3.i+t4.i+t5.i+t6.i;

POCKETFFT_PREP3

#define POCKETFFT_PREP3

(

idx

)

Value:

        T t0 = CC(idx,0,k), t1, t2; \
        PM (t1,t2,CC(idx,1,k),CC(idx,2,k)); \
        CH(idx,k,0)=t0+t1;

POCKETFFT_PREP5

#define POCKETFFT_PREP5

(

idx

)

Value:

        T t0 = CC(idx,0,k), t1, t2, t3, t4; \
        PM (t1,t4,CC(idx,1,k),CC(idx,4,k)); \
        PM (t2,t3,CC(idx,2,k),CC(idx,3,k)); \
        CH(idx,k,0).r=t0.r+t1.r+t2.r; \
        CH(idx,k,0).i=t0.i+t1.i+t2.i;

POCKETFFT_PREP7

#define POCKETFFT_PREP7

(

idx

)

Value:

        T t1 = CC(idx,0,k), t2, t3, t4, t5, t6, t7; \
        PM (t2,t7,CC(idx,1,k),CC(idx,6,k)); \
        PM (t3,t6,CC(idx,2,k),CC(idx,5,k)); \
        PM (t4,t5,CC(idx,3,k),CC(idx,4,k)); \
        CH(idx,k,0).r=t1.r+t2.r+t3.r+t4.r; \
        CH(idx,k,0).i=t1.i+t2.i+t3.i+t4.i;

POCKETFFT_REARRANGE

#define POCKETFFT_REARRANGE	(		rx,
			ix,
			ry,
			iy )

Value:

  {\
  auto t1=rx+ry, t2=ry-rx, t3=ix+iy, t4=ix-iy; \
  rx=t1; ix=t3; ry=t4; iy=t2; \
  }

POCKETFFT_RESTRICT

#define POCKETFFT_RESTRICT