#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>

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

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)

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())

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)

Definition pocketfft.h:1235

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

Definition pocketfft.h:1054

◆ 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

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ POCKETFFT_CACHE_SIZE

◆ POCKETFFT_NO_VECTORS

◆ POCKETFFT_NOINLINE

◆ POCKETFFT_PARTSTEP11

◆ POCKETFFT_PARTSTEP11a

◆ POCKETFFT_PARTSTEP11a0

◆ POCKETFFT_PARTSTEP3a

◆ POCKETFFT_PARTSTEP3b

◆ POCKETFFT_PARTSTEP5a

◆ POCKETFFT_PARTSTEP5b

◆ POCKETFFT_PARTSTEP7

◆ POCKETFFT_PARTSTEP7a

◆ POCKETFFT_PARTSTEP7a0

◆ POCKETFFT_PREP11

◆ POCKETFFT_PREP3

◆ POCKETFFT_PREP5

◆ POCKETFFT_PREP7

◆ POCKETFFT_REARRANGE

◆ POCKETFFT_RESTRICT