pocketfft::detail Namespace Reference

Namespaces
namespace	threading

Classes
struct	add_vec
struct	add_vec< cmplx< T > >
class	arr
class	arr_info
class	cfftp
struct	cmplx
class	cndarr
struct	ExecC2C
struct	ExecDcst
struct	ExecHartley
struct	ExecR2R
class	fftblue
class	multi_iter
class	ndarr
class	pocketfft_c
class	pocketfft_r
class	rev_iter
class	rfftp
class	simple_iter
class	sincos_2pibyn
class	T_dcst23
class	T_dcst4
class	T_dct1
class	T_dst1
struct	util
struct	VLEN
struct	VTYPE

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

Functions
template<typename T>
T	cos (T)=delete
template<typename T>
T	sin (T)=delete
template<typename T>
T	sqrt (T)=delete
void *	aligned_alloc (size_t align, size_t size)
void	aligned_dealloc (void *ptr)
template<typename T>
void	PM (T &a, T &b, T c, T d)
template<typename T>
void	PMINPLACE (T &a, T &b)
template<typename T>
void	MPINPLACE (T &a, T &b)
template<typename T>
cmplx< T >	conj (const cmplx< T > &a)
template<bool fwd, typename T, typename T2>
void	special_mul (const cmplx< T > &v1, const cmplx< T2 > &v2, cmplx< T > &res)
template<typename T>
void	ROT90 (cmplx< T > &a)
template<bool fwd, typename T>
void	ROTX90 (cmplx< T > &a)
template<typename T>
std::shared_ptr< T >	get_plan (size_t length)
template<typename T>
arr< char >	alloc_tmp (const shape_t &shape, size_t axsize, size_t elemsize)
template<typename T>
arr< char >	alloc_tmp (const shape_t &shape, const shape_t &axes, size_t elemsize)
template<typename T, size_t vlen>
void	copy_input (const multi_iter< vlen > &it, const cndarr< cmplx< T > > &src, cmplx< vtype_t< T > > *dst)
template<typename T, size_t vlen>
void	copy_input (const multi_iter< vlen > &it, const cndarr< T > &src, vtype_t< T > *dst)
template<typename T, size_t vlen>
void	copy_input (const multi_iter< vlen > &it, const cndarr< T > &src, T *dst)
template<typename T, size_t vlen>
void	copy_output (const multi_iter< vlen > &it, const cmplx< vtype_t< T > > *src, ndarr< cmplx< T > > &dst)
template<typename T, size_t vlen>
void	copy_output (const multi_iter< vlen > &it, const vtype_t< T > *src, ndarr< T > &dst)
template<typename T, size_t vlen>
void	copy_output (const multi_iter< vlen > &it, const T *src, ndarr< T > &dst)
template<typename Tplan, typename T, typename T0, typename Exec>
void	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	copy_hartley (const multi_iter< vlen > &it, const vtype_t< T > *src, ndarr< T > &dst)
template<typename T, size_t vlen>
void	copy_hartley (const multi_iter< vlen > &it, const T *src, ndarr< T > &dst)
template<typename T>
void	general_r2c (const cndarr< T > &in, ndarr< cmplx< T > > &out, size_t axis, bool forward, T fct, size_t nthreads)
template<typename T>
void	general_c2r (const cndarr< cmplx< T > > &in, ndarr< T > &out, size_t axis, bool forward, T fct, size_t nthreads)
template<typename T>
void	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	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	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	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	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	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	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	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	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	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	FORWARD = true
constexpr bool	BACKWARD = false

Typedef Documentation

add_vec_t

template<typename T>

using pocketfft::detail::add_vec_t = typename add_vec<T>::type

shape_t

using pocketfft::detail::shape_t = std::vector<size_t>

stride_t

using pocketfft::detail::stride_t = std::vector<ptrdiff_t>

vtype_t

template<typename T>

using pocketfft::detail::vtype_t = typename VTYPE<T>::type

Function Documentation

aligned_alloc()

void * pocketfft::detail::aligned_alloc ( size_t align, size_t size )

inline

aligned_dealloc()

void pocketfft::detail::aligned_dealloc ( void * ptr )

inline

alloc_tmp() [1/2]

template<typename T>

arr< char > pocketfft::detail::alloc_tmp	(	const shape_t &	shape,
		const shape_t &	axes,
		size_t	elemsize )

alloc_tmp() [2/2]

template<typename T>

arr< char > pocketfft::detail::alloc_tmp	(	const shape_t &	shape,
		size_t	axsize,
		size_t	elemsize )

c2c()

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 )

c2r() [1/2]

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 )

c2r() [2/2]

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 )

conj()

template<typename T>

cmplx< T > pocketfft::detail::conj

(

const cmplx< T > &

a

)

copy_hartley() [1/2]

template<typename T, size_t vlen>

void pocketfft::detail::copy_hartley	(	const multi_iter< vlen > &	it,
		const T *	src,
		ndarr< T > &	dst )

copy_hartley() [2/2]

template<typename T, size_t vlen>

void pocketfft::detail::copy_hartley	(	const multi_iter< vlen > &	it,
		const vtype_t< T > *	src,
		ndarr< T > &	dst )

copy_input() [1/3]

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 )

copy_input() [2/3]

template<typename T, size_t vlen>

void pocketfft::detail::copy_input	(	const multi_iter< vlen > &	it,
		const cndarr< T > &	src,
		T *	dst )

copy_input() [3/3]

template<typename T, size_t vlen>

void pocketfft::detail::copy_input	(	const multi_iter< vlen > &	it,
		const cndarr< T > &	src,
		vtype_t< T > *	dst )

copy_output() [1/3]

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 )

copy_output() [2/3]

template<typename T, size_t vlen>

void pocketfft::detail::copy_output	(	const multi_iter< vlen > &	it,
		const T *	src,
		ndarr< T > &	dst )

copy_output() [3/3]

template<typename T, size_t vlen>

void pocketfft::detail::copy_output	(	const multi_iter< vlen > &	it,
		const vtype_t< T > *	src,
		ndarr< T > &	dst )

cos()

template<typename T>

T pocketfft::detail::cos ( T )

delete

dct()

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 )

dst()

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 )

general_c2r()

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 )

general_nd()

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 )

general_r2c()

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 )

get_plan()

template<typename T>

std::shared_ptr< T > pocketfft::detail::get_plan

(

size_t

length

)

MPINPLACE()

template<typename T>

void pocketfft::detail::MPINPLACE ( T & a, T & b )

inline

PM()

template<typename T>

void pocketfft::detail::PM ( T & a, T & b, T c, T d )

inline

PMINPLACE()

template<typename T>

void pocketfft::detail::PMINPLACE ( T & a, T & b )

inline

r2c() [1/2]

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 )

r2c() [2/2]

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 )

r2r_fftpack()

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 )

r2r_genuine_hartley()

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 )

r2r_separable_hartley()

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 )

ROT90()

template<typename T>

void pocketfft::detail::ROT90

(

cmplx< T > &

a

)

ROTX90()

template<bool fwd, typename T>

void pocketfft::detail::ROTX90

(

cmplx< T > &

a

)

sin()

template<typename T>

T pocketfft::detail::sin ( T )

delete

special_mul()

template<bool fwd, typename T, typename T2>

void pocketfft::detail::special_mul	(	const cmplx< T > &	v1,
		const cmplx< T2 > &	v2,
		cmplx< T > &	res )

sqrt()

template<typename T>

T pocketfft::detail::sqrt ( T )

delete

Variable Documentation

BACKWARD

bool pocketfft::detail::BACKWARD = false

FORWARD

bool pocketfft::detail::FORWARD = true

constexpr