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);
}
void ComplexProducer::run() {
ComplexVector * out = produce(output);
out->clear_items();
msg = "producing ";
for (int k=0; k<16; k++) {
//std::complex<double> c = exp(i*2*k*M_PI/16.0);
std::complex<double> c = cos(2*k*M_PI/16)+i*sin(2*k*M_PI/16);
out->put_item(c);
msg += to_string(c.real()) + "," + to_string(c.imag()) + "i ";
}
log(msg);
//timer.randSleep(200);
if(number >= last)
setEos(output);
number += step;
release(output);
}
void displayData(const ComplexVector<T> &data, ImageSize size, const QString& title)
{
std::vector<T> dataValue;
int n0 = size.x;
int n1 = size.y;
int n2 = size.z;
if (n2 < 2) n2 = 2;
int nImages = 4;
int start = (n0 * n1) * (n2 / 2 - 3);
int end = (n0 * n1) * (n2 / 2 - 3 + nImages);
for (auto it = data.begin() + start; it < data.begin() + end; it++) {
float value = std::abs(*it);
dataValue.push_back(value);
}
float max = *std::max_element(dataValue.begin(), dataValue.end());
float min = *std::min_element(dataValue.begin(), dataValue.end());
QImage dataImage(n1 * nImages, n0, QImage::Format_Indexed8);
for (int i = 0; i < 256; i++) {
dataImage.setColor(i, qRgb(i, i, i));
}
int i = 0;
for (int y = 0; y < n0; y++) {
auto imageLine = dataImage.scanLine(y);
i = y * n1;
for (int j = 0; j < nImages; j++)
{
for (int x = j * n0; x < j * n0 + n1; x++)
{
Q_ASSERT(i < dataValue.size());
uint idx;
if (max == min)
idx = 127;
else
idx = (dataValue[i] - min) / (max - min) * 255;
imageLine[x] = idx;
i++;
}
i += n0 * (n1 - 1);
}
}
QPixmap pixmap = QPixmap::fromImage(dataImage);
QLabel *imgWnd = new QLabel("Image Window");
imgWnd->setWindowTitle(title);
imgWnd->setPixmap(pixmap);
imgWnd->show();
}
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
}
// [[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 NRLib::WriteComplexVector(const std::string & header,
const ComplexVector & c)
{
int n = c.length();
LogKit::LogFormatted(LogKit::Error,"\n"+header+"\n");
for (int i=0; i < n ; i++) {
LogKit::LogFormatted(LogKit::Error,"(%12.8f, %12.8f)\n",c(i).real(),c(i).imag());
}
LogKit::LogFormatted(LogKit::Error,"\n");
}
// 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]);
}
}
void run_test(const Matrix &mat, int k, int m)
{
DenseGenMatProd<double> op(mat);
GenEigsSolver<double, SelectionRule, DenseGenMatProd<double>> eigs(&op, k, m);
eigs.init();
int nconv = eigs.compute();
int niter = eigs.num_iterations();
int nops = eigs.num_operations();
REQUIRE( nconv > 0 );
ComplexVector evals = eigs.eigenvalues();
ComplexMatrix evecs = eigs.eigenvectors();
ComplexMatrix err = mat * evecs - evecs * evals.asDiagonal();
INFO( "nconv = " << nconv );
INFO( "niter = " << niter );
INFO( "nops = " << nops );
INFO( "||AU - UD||_inf = " << err.array().abs().maxCoeff() );
REQUIRE( err.array().abs().maxCoeff() == Approx(0.0) );
}
void ImageFilter<T>::crop(const ImageSize &imageSize)
{
auto size = m_associatedData.imageSize();
auto x0 = (size.x - imageSize.x) / 2;
auto y0 = (size.y - imageSize.y) / 2;
auto z0 = (size.z - imageSize.z) / 2;
if (x0 < 0 || y0 < 0 || z0 < 0) {
std::cerr << "Crop size larger than image" << std::endl;
return;
}
ComplexVector<T> out;
ImageData<T> img(m_associatedData.dim(), imageSize);
for (int n = 0; n < m_associatedData.channels(); n++)
{
out.resize(imageSize.x * imageSize.y * imageSize.z);
auto itOut = out.begin();
auto itInput = m_associatedData.getChannelImage(n)->cbegin();
for (auto z = 0ul; z < imageSize.z; z++)
{
auto in1 = (z + z0) * (size.x * size.y) + y0 * size.x;
for (auto y = 0ul; y < imageSize.y; y++)
{
auto in2 = y * size.x + in1 + x0;
for (auto x = 0ul; x < imageSize.x; x++)
{
auto in3 = x + in2;
*(itOut++) = *(itInput + in3);
}
}
}
img.addChannelImage(std::move(out));
}
m_associatedData = std::move(img);
}
void run_test(const MatType& mat, int k, int m, double sigma, bool allow_fail = false)
{
typename OpTypeTrait<MatType>::OpType op(mat);
GenEigsRealShiftSolver<double, SelectionRule, typename OpTypeTrait<MatType>::OpType>
eigs(&op, k, m, sigma);
eigs.init();
int nconv = eigs.compute();
int niter = eigs.num_iterations();
int nops = eigs.num_operations();
if(allow_fail)
{
if( eigs.info() != SUCCESSFUL )
{
WARN( "FAILED on this test" );
std::cout << "nconv = " << nconv << std::endl;
std::cout << "niter = " << niter << std::endl;
std::cout << "nops = " << nops << std::endl;
return;
}
} else {
INFO( "nconv = " << nconv );
INFO( "niter = " << niter );
INFO( "nops = " << nops );
REQUIRE( eigs.info() == SUCCESSFUL );
}
ComplexVector evals = eigs.eigenvalues();
ComplexMatrix evecs = eigs.eigenvectors();
ComplexMatrix resid = mat * evecs - evecs * evals.asDiagonal();
const double err = resid.array().abs().maxCoeff();
INFO( "||AU - UD||_inf = " << err );
REQUIRE( err == Approx(0.0) );
}
void BitReverse::run() {
ComplexVector * in = consume(input);
for (int ii = 0, j = 1; j < in->vector_size()-1; j++) {
for (int k = in->vector_size() >> 1; k > (ii ^= k); k >>= 1);
if (ii < j) in->swap_item(ii, j);
}
msg = "consuming \n";
for (int k=0; k<in->vector_size(); k++) {
item = in->get_item(k);
msg += to_string(item.real())+","+to_string(item.imag())+"i ";
}
log(msg);
//timer.randSleep(200);
release(input);
}
/// 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());
}
