25 static bool push_precalculated(
int uk,
int fftlength,
26 std::vector<unsigned> &is,
27 std::vector<unsigned> &js,
28 std::vector<double> &real,
29 std::vector<double> &imag)
31 if (uk == 76 && fftlength == 16384) {
32 push_76_16384(is, js, real, imag);
35 if (uk == 144 && fftlength == 4096) {
36 push_144_4096(is, js, real, imag);
39 if (uk == 65 && fftlength == 2048) {
40 push_65_2048(is, js, real, imag);
43 if (uk == 84 && fftlength == 65536) {
44 push_84_65536(is, js, real, imag);
54 double y = ceil(log(x)/log(2.0));
94 double* hammingWindowRe =
new double [
m_FFTLength ];
95 double* hammingWindowIm =
new double [
m_FFTLength ];
96 double* transfHammingWindowRe =
new double [
m_FFTLength ];
97 double* transfHammingWindowIm =
new double [
m_FFTLength ];
101 hammingWindowRe[u] = 0;
102 hammingWindowIm[u] = 0;
108 sk->
is.reserve( m_FFTLength*2 );
109 sk->
js.reserve( m_FFTLength*2 );
110 sk->
real.reserve( m_FFTLength*2 );
111 sk->
imag.reserve( m_FFTLength*2 );
118 FFT m_FFT(m_FFTLength);
120 for (
unsigned k =
m_uK; k--; )
124 hammingWindowRe[u] = 0;
125 hammingWindowIm[u] = 0;
129 const unsigned hammingLength = (int) ceil(
m_dQ *
m_FS / (
m_FMin * pow(2,((
double)(k))/(
double)
m_BPO)));
131 unsigned origin = m_FFTLength/2 - hammingLength/2;
133 for (
unsigned i=0; i<hammingLength; i++)
135 const double angle = 2*
PI*
m_dQ*i/hammingLength;
136 const double real = cos(angle);
137 const double imag = sin(angle);
138 const double absol =
hamming(hammingLength, i)/hammingLength;
139 hammingWindowRe[ origin + i ] = absol*real;
140 hammingWindowIm[ origin + i ] = absol*imag;
143 for (
unsigned i = 0; i < m_FFTLength/2; ++i) {
144 double temp = hammingWindowRe[i];
145 hammingWindowRe[i] = hammingWindowRe[i + m_FFTLength/2];
146 hammingWindowRe[i + m_FFTLength/2] = temp;
147 temp = hammingWindowIm[i];
148 hammingWindowIm[i] = hammingWindowIm[i + m_FFTLength/2];
149 hammingWindowIm[i + m_FFTLength/2] = temp;
153 m_FFT.
process( 0, hammingWindowRe, hammingWindowIm, transfHammingWindowRe, transfHammingWindowIm );
159 const double squaredBin =
squaredModule( transfHammingWindowRe[ j ], transfHammingWindowIm[ j ]);
160 if (squaredBin <= squareThreshold)
continue;
167 sk->
real.push_back( transfHammingWindowRe[ j ]/m_FFTLength);
168 sk->
imag.push_back(-transfHammingWindowIm[ j ]/m_FFTLength);
173 delete [] hammingWindowRe;
174 delete [] hammingWindowIm;
175 delete [] transfHammingWindowRe;
176 delete [] transfHammingWindowIm;
253 std::cerr <<
"ERROR: ConstantQ::process: Sparse kernel has not been initialised" << std::endl;
259 for (
unsigned row=0; row<2*
m_uK; row++)
264 const unsigned *fftbin = &(sk->
is[0]);
265 const unsigned *cqbin = &(sk->
js[0]);
266 const double *real = &(sk->
real[0]);
267 const double *imag = &(sk->
imag[0]);
268 const unsigned int sparseCells = sk->
real.size();
270 for (
unsigned i = 0; i<sparseCells; i++)
272 const unsigned row = cqbin[i];
273 const unsigned col = fftbin[i];
274 const double & r1 = real[i];
275 const double & i1 = imag[i];
276 const double & r2 = fftdata[ (2*
m_FFTLength) - 2*col - 2 ];
277 const double & i2 = fftdata[ (2*
m_FFTLength) - 2*col - 2 + 1 ];
279 m_CQdata[ 2*row ] += (r1*r2 - i1*i2);
280 m_CQdata[ 2*row+1] += (r1*i2 + i1*r2);
318 double *CQRe,
double *CQIm)
321 std::cerr <<
"ERROR: ConstantQ::process: Sparse kernel has not been initialised" << std::endl;
327 for (
unsigned row=0; row<
m_uK; row++)
333 const unsigned *fftbin = &(sk->
is[0]);
334 const unsigned *cqbin = &(sk->
js[0]);
335 const double *real = &(sk->
real[0]);
336 const double *imag = &(sk->
imag[0]);
337 const unsigned int sparseCells = sk->
real.size();
339 for (
unsigned i = 0; i<sparseCells; i++)
341 const unsigned row = cqbin[i];
342 const unsigned col = fftbin[i];
343 const double & r1 = real[i];
344 const double & i1 = imag[i];
345 const double & r2 = FFTRe[
m_FFTLength - col - 1 ];
346 const double & i2 = FFTIm[
m_FFTLength - col - 1 ];
348 CQRe[ row ] += (r1*r2 - i1*i2);
349 CQIm[ row ] += (r1*i2 + i1*r2);
std::vector< unsigned > is
ConstantQ(CQConfig Config)
std::vector< double > real
static double nextpow2(double x)
void process(const double *FFTRe, const double *FFTIm, double *CQRe, double *CQIm)
static double squaredModule(const double &xx, const double &yy)
SparseKernel * m_sparseKernel
std::vector< double > imag
void process(bool inverse, const double *realIn, const double *imagIn, double *realOut, double *imagOut)
Carry out a forward or inverse transform (depending on the value of inverse) of size nsamples...
double hamming(int len, int n)
void initialise(CQConfig Config)
std::vector< unsigned > js