mirror/kissfft
1
0
Fork 0
mirror of https://github.com/mborgerding/kissfft.git synced 2025-06-04 01:28:23 -04:00
Code Issues Packages Projects Releases Wiki Activity

Improved code quality.

Browse Source 
* Replaced int by std::size_t where appropriate.
* Made traits member functions static.
* Removed redundant data from traits class.
* Made local variables const where possible.
* Made mutable variables as local as possible.
* Removed redundant variables.
* Improved white-space formatting for readability (sparingly).
This commit is contained in:
Ralph Tandetzky 2016-04-21 11:41:53 +02:00
parent 3c96a24710
commit f78c115f92
1 changed files with 76 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
kissfft.hh
View File

@ -10,27 +10,29 @@ struct traits
{ {
typedef T_scalar scalar_type; typedef T_scalar scalar_type;
typedef std::complex<scalar_type> cpx_type; typedef std::complex<scalar_type> cpx_type;
void fill_twiddles( std::complex<T_scalar> * dst ,int nfft,bool inverse) static void fill_twiddles( cpx_type * dst,
std::size_t nfft,
bool inverse )
{ {
T_scalar phinc = (inverse?2:-2)* acos( (T_scalar) -1) / nfft; T_scalar phinc = (inverse?2:-2)* acos( (T_scalar) -1) / nfft;
for (int i=0;i<nfft;++i) for (std::size_t i=0;i<nfft;++i)
dst[i] = exp( std::complex<T_scalar>(0,i*phinc) ); dst[i] = std::exp( cpx_type(0,i*phinc) );
} }
void prepare( static void prepare(
std::vector< std::complex<T_scalar> > & dst, std::vector< cpx_type > & _twiddles,
int nfft,bool inverse, std::size_t nfft,
std::vector<int> & stageRadix, bool inverse,
std::vector<int> & stageRemainder ) std::vector<std::size_t> & stageRadix,
std::vector<std::size_t> & stageRemainder )
{ {
_twiddles.resize(nfft); _twiddles.resize(nfft);
fill_twiddles( &_twiddles[0],nfft,inverse); fill_twiddles( &_twiddles[0],nfft,inverse);
dst = _twiddles;
//factorize //factorize
//start factoring out 4's, then 2's, then 3,5,7,9,... //start factoring out 4's, then 2's, then 3,5,7,9,...
int n= nfft; std::size_t n= nfft;
int p=4; std::size_t p=4;
do { do {
while (n % p) { while (n % p) {
switch (p) { switch (p) {
@ -39,17 +41,13 @@ struct traits
default: p += 2; break; default: p += 2; break;
} }
if (p*p>n) if (p*p>n)
p=n;// no more factors p = n;// no more factors
} }
n /= p; n /= p;
stageRadix.push_back(p); stageRadix.push_back(p);
stageRemainder.push_back(n); stageRemainder.push_back(n);
}while(n>1); }while(n>1);
} }
std::vector<cpx_type> _twiddles;
const cpx_type twiddle(int i) const { return _twiddles[i]; }
}; };
} }
@ -64,24 +62,31 @@ class kissfft
typedef typename traits_type::scalar_type scalar_type; typedef typename traits_type::scalar_type scalar_type;
typedef typename traits_type::cpx_type cpx_type; typedef typename traits_type::cpx_type cpx_type;
kissfft(int nfft,bool inverse,const traits_type & traits=traits_type() ) kissfft( std::size_t nfft,
:_nfft(nfft),_inverse(inverse),_traits(traits) bool inverse )
:_nfft(nfft)
,_inverse(inverse)
{ {
_traits.prepare(_twiddles, _nfft,_inverse ,_stageRadix, _stageRemainder); T_traits::prepare(_twiddles, _nfft,_inverse ,_stageRadix, _stageRemainder);
} }
void transform(const cpx_type * src , cpx_type * dst) const void transform( const cpx_type * src,
cpx_type * dst ) const
{ {
kf_work(0, dst, src, 1,1); kf_work(0, dst, src, 1,1);
} }
private: private:
void kf_work( int stage,cpx_type * Fout, const cpx_type * f, size_t fstride,size_t in_stride) const void kf_work( std::size_t stage,
cpx_type * Fout,
const cpx_type * f,
std::size_t fstride,
std::size_t in_stride) const
{ {
int p = _stageRadix[stage]; const std::size_t p = _stageRadix[stage];
int m = _stageRemainder[stage]; const std::size_t m = _stageRemainder[stage];
cpx_type * Fout_beg = Fout; cpx_type * const Fout_beg = Fout;
cpx_type * Fout_end = Fout + p*m; cpx_type * const Fout_end = Fout + p*m;
if (m==1) { if (m==1) {
do{ do{
@ -121,45 +126,45 @@ class kissfft
static scalar_type HALF_OF( const scalar_type & a) { return a*.5;} static scalar_type HALF_OF( const scalar_type & a) { return a*.5;}
static void C_MULBYSCALAR(cpx_type & c,const scalar_type & a) {c*=a;} static void C_MULBYSCALAR(cpx_type & c,const scalar_type & a) {c*=a;}
void kf_bfly2( cpx_type * Fout, const size_t fstride, int m) const void kf_bfly2( cpx_type * Fout, const size_t fstride, std::size_t m) const
{ {
for (int k=0;k<m;++k) { for (std::size_t k=0;k<m;++k) {
cpx_type t = Fout[m+k] * _traits.twiddle(k*fstride); cpx_type t = Fout[m+k] * _twiddles[k*fstride];
Fout[m+k] = Fout[k] - t; Fout[m+k] = Fout[k] - t;
Fout[k] += t; Fout[k] += t;
} }
} }
void kf_bfly4( cpx_type * Fout, const size_t fstride, const size_t m) const void kf_bfly4( cpx_type * Fout, const std::size_t fstride, const std::size_t m) const
{ {
cpx_type scratch[7]; cpx_type scratch[7];
int negative_if_inverse = _inverse * -2 +1; const scalar_type negative_if_inverse = _inverse ? -1 : +1;
for (size_t k=0;k<m;++k) { for (std::size_t k=0;k<m;++k) {
scratch[0] = Fout[k+m] * _traits.twiddle(k*fstride); scratch[0] = Fout[k+ m] * _twiddles[k*fstride ];
scratch[1] = Fout[k+2*m] * _traits.twiddle(k*fstride*2); scratch[1] = Fout[k+2*m] * _twiddles[k*fstride*2];
scratch[2] = Fout[k+3*m] * _traits.twiddle(k*fstride*3); scratch[2] = Fout[k+3*m] * _twiddles[k*fstride*3];
scratch[5] = Fout[k] - scratch[1]; scratch[5] = Fout[k] - scratch[1];
Fout[k] += scratch[1]; Fout[k] += scratch[1];
scratch[3] = scratch[0] + scratch[2]; scratch[3] = scratch[0] + scratch[2];
scratch[4] = scratch[0] - scratch[2]; scratch[4] = scratch[0] - scratch[2];
scratch[4] = cpx_type( scratch[4].imag()*negative_if_inverse , -scratch[4].real()* negative_if_inverse ); scratch[4] = cpx_type( scratch[4].imag()*negative_if_inverse ,
-scratch[4].real()*negative_if_inverse );
Fout[k+2*m] = Fout[k] - scratch[3]; Fout[k+2*m] = Fout[k] - scratch[3];
Fout[k] += scratch[3]; Fout[k ]+= scratch[3];
Fout[k+m] = scratch[5] + scratch[4]; Fout[k+ m] = scratch[5] + scratch[4];
Fout[k+3*m] = scratch[5] - scratch[4]; Fout[k+3*m] = scratch[5] - scratch[4];
} }
} }
void kf_bfly3( cpx_type * Fout, const size_t fstride, const size_t m) const void kf_bfly3( cpx_type * Fout, const std::size_t fstride, const std::size_t m) const
{ {
size_t k=m; std::size_t k=m;
const size_t m2 = 2*m; const std::size_t m2 = 2*m;
const cpx_type *tw1,*tw2; const cpx_type *tw1,*tw2;
cpx_type scratch[5]; cpx_type scratch[5];
cpx_type epi3; const cpx_type epi3 = _twiddles[fstride*m];
epi3 = _twiddles[fstride*m];
tw1=tw2=&_twiddles[0]; tw1=tw2=&_twiddles[0];
@ -187,16 +192,12 @@ class kissfft
}while(--k); }while(--k);
} }
void kf_bfly5( cpx_type * Fout, const size_t fstride, const size_t m) const void kf_bfly5( cpx_type * Fout, const std::size_t fstride, const std::size_t m) const
{ {
cpx_type *Fout0,*Fout1,*Fout2,*Fout3,*Fout4; cpx_type *Fout0,*Fout1,*Fout2,*Fout3,*Fout4;
size_t u;
cpx_type scratch[13]; cpx_type scratch[13];
const cpx_type * twiddles = &_twiddles[0]; const cpx_type ya = _twiddles[fstride*m];
const cpx_type *tw; const cpx_type yb = _twiddles[fstride*2*m];
cpx_type ya,yb;
ya = twiddles[fstride*m];
yb = twiddles[fstride*2*m];
Fout0=Fout; Fout0=Fout;
Fout1=Fout0+m; Fout1=Fout0+m;
@ -204,15 +205,14 @@ class kissfft
Fout3=Fout0+3*m; Fout3=Fout0+3*m;
Fout4=Fout0+4*m; Fout4=Fout0+4*m;
tw=twiddles; for ( std::size_t u=0; u<m; ++u ) {
for ( u=0; u<m; ++u ) {
C_FIXDIV( *Fout0,5); C_FIXDIV( *Fout1,5); C_FIXDIV( *Fout2,5); C_FIXDIV( *Fout3,5); C_FIXDIV( *Fout4,5); C_FIXDIV( *Fout0,5); C_FIXDIV( *Fout1,5); C_FIXDIV( *Fout2,5); C_FIXDIV( *Fout3,5); C_FIXDIV( *Fout4,5);
scratch[0] = *Fout0; scratch[0] = *Fout0;
C_MUL(scratch[1] ,*Fout1, tw[u*fstride]); C_MUL(scratch[1] ,*Fout1, _twiddles[u*fstride]);
C_MUL(scratch[2] ,*Fout2, tw[2*u*fstride]); C_MUL(scratch[2] ,*Fout2, _twiddles[2*u*fstride]);
C_MUL(scratch[3] ,*Fout3, tw[3*u*fstride]); C_MUL(scratch[3] ,*Fout3, _twiddles[3*u*fstride]);
C_MUL(scratch[4] ,*Fout4, tw[4*u*fstride]); C_MUL(scratch[4] ,*Fout4, _twiddles[4*u*fstride]);
C_ADD( scratch[7],scratch[1],scratch[4]); C_ADD( scratch[7],scratch[1],scratch[4]);
C_SUB( scratch[10],scratch[1],scratch[4]); C_SUB( scratch[10],scratch[1],scratch[4]);
@ -223,7 +223,7 @@ class kissfft
C_ADDTO( *Fout0, scratch[8]); C_ADDTO( *Fout0, scratch[8]);
scratch[5] = scratch[0] + cpx_type( scratch[5] = scratch[0] + cpx_type(
S_MUL(scratch[7].real(),ya.real() ) + S_MUL(scratch[8].real() ,yb.real() ), S_MUL(scratch[7].real(),ya.real()) + S_MUL(scratch[8].real(),yb.real() ),
S_MUL(scratch[7].imag(),ya.real()) + S_MUL(scratch[8].imag(),yb.real()) S_MUL(scratch[7].imag(),ya.real()) + S_MUL(scratch[8].imag(),yb.real())
); );
@ -243,13 +243,17 @@ class kissfft
scratch[12] = cpx_type( scratch[12] = cpx_type(
-S_MUL(scratch[10].imag(),yb.imag()) + S_MUL(scratch[9].imag(),ya.imag()), -S_MUL(scratch[10].imag(),yb.imag()) + S_MUL(scratch[9].imag(),ya.imag()),
S_MUL(scratch[10].real(),yb.imag()) - S_MUL(scratch[9].real(),ya.imag()) S_MUL(scratch[10].real(),yb.imag()) - S_MUL(scratch[9].real(),ya.imag())
); );
C_ADD(*Fout2,scratch[11],scratch[12]); C_ADD(*Fout2,scratch[11],scratch[12]);
C_SUB(*Fout3,scratch[11],scratch[12]); C_SUB(*Fout3,scratch[11],scratch[12]);
++Fout0;++Fout1;++Fout2;++Fout3;++Fout4; ++Fout0;
++Fout1;
++Fout2;
++Fout3;
++Fout4;
} }
} }
@ -257,31 +261,30 @@ class kissfft
void kf_bfly_generic( void kf_bfly_generic(
cpx_type * Fout, cpx_type * Fout,
const size_t fstride, const size_t fstride,
int m, std::size_t m,
int p std::size_t p
) const ) const
{ {
int u,k,q1,q;
const cpx_type * twiddles = &_twiddles[0]; const cpx_type * twiddles = &_twiddles[0];
cpx_type t;
int Norig = _nfft;
cpx_type scratchbuf[p]; cpx_type scratchbuf[p];
for ( u=0; u<m; ++u ) { for ( std::size_t u=0; u<m; ++u ) {
k=u; std::size_t k = u;
for ( q1=0 ; q1<p ; ++q1 ) { for ( std::size_t q1=0 ; q1<p ; ++q1 ) {
scratchbuf[q1] = Fout[ k ]; scratchbuf[q1] = Fout[ k ];
C_FIXDIV(scratchbuf[q1],p); C_FIXDIV(scratchbuf[q1],p);
k += m; k += m;
} }
k=u; k=u;
for ( q1=0 ; q1<p ; ++q1 ) { for ( std::size_t q1=0 ; q1<p ; ++q1 ) {
int twidx=0; std::size_t twidx=0;
Fout[ k ] = scratchbuf[0]; Fout[ k ] = scratchbuf[0];
for (q=1;q<p;++q ) { for ( std::size_t q=1;q<p;++q ) {
twidx += fstride * k; twidx += fstride * k;
if (twidx>=Norig) twidx-=Norig; if (twidx>=_nfft)
twidx-=_nfft;
cpx_type t;
C_MUL(t,scratchbuf[q] , twiddles[twidx] ); C_MUL(t,scratchbuf[q] , twiddles[twidx] );
C_ADDTO( Fout[ k ] ,t); C_ADDTO( Fout[ k ] ,t);
} }
@ -290,11 +293,10 @@ class kissfft
} }
} }
int _nfft; std::size_t _nfft;
bool _inverse; bool _inverse;
std::vector<cpx_type> _twiddles; std::vector<cpx_type> _twiddles;
std::vector<int> _stageRadix; std::vector<std::size_t> _stageRadix;
std::vector<int> _stageRemainder; std::vector<std::size_t> _stageRemainder;
traits_type _traits;
}; };
#endif #endif