void Filter::setCoordinates (ComplexVector& zeros, ComplexVector& poles)
{
this->zeros->clear();
delete this->zeros;
this->poles->clear();
delete this->poles;
this->zeros = &zeros;
this->poles = &poles;
delete[] zeroBuffer.buffer;
delete[] zeroBuffer.coefficients;
delete[] poleBuffer.buffer;
delete[] poleBuffer.coefficients;
zeroBuffer.position = 0;
zeroBuffer.size = (int)zeros.size() + 1;
zeroBuffer.buffer = new float[zeroBuffer.size];
zeroBuffer.coefficients = getCoefficients(1, zeros);
poleBuffer.position = 0;
poleBuffer.size = (int)poles.size() + 1;
poleBuffer.buffer = new float[poleBuffer.size];
poleBuffer.coefficients = getCoefficients(1, poles);
}
// [[Rcpp::export]]
ComplexVector complex_CPLXSXP( ComplexVector x ){
int nn = x.size();
for( int i=0; i<nn; i++) {
x[i].r = x[i].r*2 ;
x[i].i = x[i].i*2 ;
}
return x ;
}
void test_scalar_generic(int nfft)
{
typedef typename FFT<T>::Complex Complex;
typedef typename FFT<T>::Scalar Scalar;
typedef typename VectorType<Container, Scalar>::type ScalarVector;
typedef typename VectorType<Container, Complex>::type ComplexVector;
FFT<T> fft;
ScalarVector tbuf(nfft);
ComplexVector freqBuf;
for (int k = 0; k < nfft; ++k)
tbuf[k] = (T)(rand() / (double)RAND_MAX - .5);
// make sure it DOESN'T give the right full spectrum answer
// if we've asked for half-spectrum
fft.SetFlag(fft.HalfSpectrum);
fft.fwd(freqBuf, tbuf);
VERIFY((size_t)freqBuf.size() == (size_t)((nfft >> 1) + 1));
VERIFY(fft_rmse(freqBuf, tbuf) < test_precision<T>()); // gross check
fft.ClearFlag(fft.HalfSpectrum);
fft.fwd(freqBuf, tbuf);
VERIFY((size_t)freqBuf.size() == (size_t)nfft);
VERIFY(fft_rmse(freqBuf, tbuf) < test_precision<T>()); // gross check
if (nfft & 1)
return; // odd FFTs get the wrong size inverse FFT
ScalarVector tbuf2;
fft.inv(tbuf2, freqBuf);
VERIFY(dif_rmse(tbuf, tbuf2) < test_precision<T>()); // gross check
// verify that the Unscaled flag takes effect
ScalarVector tbuf3;
fft.SetFlag(fft.Unscaled);
fft.inv(tbuf3, freqBuf);
for (int k = 0; k < nfft; ++k)
tbuf3[k] *= T(1. / nfft);
// for (size_t i=0;i<(size_t) tbuf.size();++i)
// cout << "freqBuf=" << freqBuf[i] << " in2=" << tbuf3[i] << " - in=" << tbuf[i] << " => " << (tbuf3[i] - tbuf[i] ) << endl;
VERIFY(dif_rmse(tbuf, tbuf3) < test_precision<T>()); // gross check
// verify that ClearFlag works
fft.ClearFlag(fft.Unscaled);
fft.inv(tbuf2, freqBuf);
VERIFY(dif_rmse(tbuf, tbuf2) < test_precision<T>()); // gross check
}
// response = X, signal = x
void Filter::inverseFourierTransform (ComplexVector& response, ComplexVector& signal)
{
float N = response.size();
for (int n = 0; n < signal.size(); ++n)
{
signal[n] = newComplex(0, 0);
for (int k = 0; k < response.size(); ++k)
{
float alpha = 2*M_PI * k / N * n;
Complex Z = newComplex(cosf(alpha), sinf(alpha));
signal[n] = signal[n] + (polToCar(response[k]) * Z);
}
signal[n] = signal[n] / newComplex(N, 0);
}
}
//==================================================================
// signal = x, response = X
void Filter::fourierTransform (ComplexVector& signal, ComplexVector& response)
{
float N = response.size();
for (int k = 0; k < response.size(); ++k)
{
response[k] = newComplex(0, 0);
for (int n = 0; n < signal.size(); ++n)
{
float alpha = 2*M_PI * k / N * -n;
Complex Z = newComplex(cosf(alpha), sinf(alpha));
response[k] = response[k] + (signal[n] * Z);
}
response[k] = carToPol(response[k]);
}
}
/// Copy constructor.
/// @param v :: The other vector
ComplexVector::ComplexVector(const ComplexVector &v) {
m_vector = gsl_vector_complex_alloc(v.size());
gsl_vector_complex_memcpy(m_vector, v.gsl());
}
