GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-09-13 01:43:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix clang-tidy warnings about function definitions in headers.

Browse Source
This commit is contained in:
Antonio Sanchez 2022-06-23 13:47:32 -07:00 committed by Antonio Sánchez
parent 8ed3b9dcd6
commit 0e18714167
1 changed files with 204 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

409
unsupported/test/fft_test_shared.h
View File

@ -10,269 +10,268 @@
#include "main.h" #include "main.h"
#include <unsupported/Eigen/FFT> #include <unsupported/Eigen/FFT>
template <typename T> template <typename T>
std::complex<T> RandomCpx() { return std::complex<T>( (T)(rand()/(T)RAND_MAX - .5), (T)(rand()/(T)RAND_MAX - .5) ); } inline std::complex<T> RandomCpx() {
return std::complex<T>((T)(rand() / (T)RAND_MAX - .5), (T)(rand() / (T)RAND_MAX - .5));
}
using namespace std; using namespace std;
using namespace Eigen; using namespace Eigen;
template <typename T>
inline complex<long double> promote(complex<T> x) {
return complex<long double>((long double)x.real(), (long double)x.imag());
}
template < typename T> inline complex<long double> promote(float x) { return complex<long double>((long double)x); }
complex<long double> promote(complex<T> x) { return complex<long double>((long double)x.real(),(long double)x.imag()); } inline complex<long double> promote(double x) { return complex<long double>((long double)x); }
inline complex<long double> promote(long double x) { return complex<long double>((long double)x); }
complex<long double> promote(float x) { return complex<long double>((long double)x); } template <typename VT1, typename VT2>
complex<long double> promote(double x) { return complex<long double>((long double)x); } long double fft_rmse(const VT1& fftbuf, const VT2& timebuf) {
complex<long double> promote(long double x) { return complex<long double>((long double)x); } long double totalpower = 0;
long double difpower = 0;
long double pi = acos((long double)-1);
template <typename VT1,typename VT2> for (size_t k0 = 0; k0 < (size_t)fftbuf.size(); ++k0) {
long double fft_rmse( const VT1 & fftbuf,const VT2 & timebuf) complex<long double> acc = 0;
{ long double phinc = (long double)(-2.) * k0 * pi / timebuf.size();
long double totalpower=0; for (size_t k1 = 0; k1 < (size_t)timebuf.size(); ++k1) {
long double difpower=0; acc += promote(timebuf[k1]) * exp(complex<long double>(0, k1 * phinc));
long double pi = acos((long double)-1 );
for (size_t k0=0;k0<(size_t)fftbuf.size();++k0) {
complex<long double> acc = 0;
long double phinc = (long double)(-2.)*k0* pi / timebuf.size();
for (size_t k1=0;k1<(size_t)timebuf.size();++k1) {
acc += promote( timebuf[k1] ) * exp( complex<long double>(0,k1*phinc) );
}
totalpower += numext::abs2(acc);
complex<long double> x = promote(fftbuf[k0]);
complex<long double> dif = acc - x;
difpower += numext::abs2(dif);
//cerr << k0 << "\t" << acc << "\t" << x << "\t" << sqrt(numext::abs2(dif)) << endl;
}
// cerr << "rmse:" << sqrt(difpower/totalpower) << endl;
return sqrt(difpower/totalpower);
} }
totalpower += numext::abs2(acc);
complex<long double> x = promote(fftbuf[k0]);
complex<long double> dif = acc - x;
difpower += numext::abs2(dif);
// cerr << k0 << "\t" << acc << "\t" << x << "\t" << sqrt(numext::abs2(dif)) << endl;
}
// cerr << "rmse:" << sqrt(difpower/totalpower) << endl;
return sqrt(difpower / totalpower);
}
template <typename VT1,typename VT2> template <typename VT1, typename VT2>
long double dif_rmse( const VT1 buf1,const VT2 buf2) long double dif_rmse(const VT1 buf1, const VT2 buf2) {
{ long double totalpower = 0;
long double totalpower=0; long double difpower = 0;
long double difpower=0; size_t n = (min)(buf1.size(), buf2.size());
size_t n = (min)( buf1.size(),buf2.size() ); for (size_t k = 0; k < n; ++k) {
for (size_t k=0;k<n;++k) { totalpower += (long double)((numext::abs2(buf1[k]) + numext::abs2(buf2[k])) / 2);
totalpower += (long double)((numext::abs2( buf1[k] ) + numext::abs2(buf2[k]) )/2); difpower += (long double)(numext::abs2(buf1[k] - buf2[k]));
difpower += (long double)(numext::abs2(buf1[k] - buf2[k])); }
} return sqrt(difpower / totalpower);
return sqrt(difpower/totalpower); }
}
enum { StdVectorContainer, EigenVectorContainer }; enum { StdVectorContainer, EigenVectorContainer };
template<int Container, typename Scalar> struct VectorType; template <int Container, typename Scalar>
struct VectorType;
template<typename Scalar> struct VectorType<StdVectorContainer,Scalar> template <typename Scalar>
{ struct VectorType<StdVectorContainer, Scalar> {
typedef vector<Scalar> type; typedef vector<Scalar> type;
}; };
template<typename Scalar> struct VectorType<EigenVectorContainer,Scalar> template <typename Scalar>
{ struct VectorType<EigenVectorContainer, Scalar> {
typedef Matrix<Scalar,Dynamic,1> type; typedef Matrix<Scalar, Dynamic, 1> type;
}; };
template <int Container, typename T> template <int Container, typename T>
void test_scalar_generic(int nfft) void test_scalar_generic(int nfft) {
{ typedef typename FFT<T>::Complex Complex;
typedef typename FFT<T>::Complex Complex; typedef typename FFT<T>::Scalar Scalar;
typedef typename FFT<T>::Scalar Scalar; typedef typename VectorType<Container, Scalar>::type ScalarVector;
typedef typename VectorType<Container,Scalar>::type ScalarVector; typedef typename VectorType<Container, Complex>::type ComplexVector;
typedef typename VectorType<Container,Complex>::type ComplexVector;
FFT<T> fft; FFT<T> fft;
ScalarVector tbuf(nfft); ScalarVector tbuf(nfft);
ComplexVector freqBuf; ComplexVector freqBuf;
for (int k=0;k<nfft;++k) for (int k = 0; k < nfft; ++k) tbuf[k] = (T)(rand() / (double)RAND_MAX - .5);
tbuf[k]= (T)( rand()/(double)RAND_MAX - .5);
// make sure it DOESN'T give the right full spectrum answer // make sure it DOESN'T give the right full spectrum answer
// if we've asked for half-spectrum // if we've asked for half-spectrum
fft.SetFlag(fft.HalfSpectrum ); fft.SetFlag(fft.HalfSpectrum);
fft.fwd( freqBuf,tbuf); fft.fwd(freqBuf, tbuf);
VERIFY((size_t)freqBuf.size() == (size_t)( (nfft>>1)+1) ); VERIFY((size_t)freqBuf.size() == (size_t)((nfft >> 1) + 1));
VERIFY( T(fft_rmse(freqBuf,tbuf)) < test_precision<T>() );// gross check VERIFY(T(fft_rmse(freqBuf, tbuf)) < test_precision<T>()); // gross check
fft.ClearFlag(fft.HalfSpectrum ); fft.ClearFlag(fft.HalfSpectrum);
fft.fwd( freqBuf,tbuf); fft.fwd(freqBuf, tbuf);
VERIFY( (size_t)freqBuf.size() == (size_t)nfft); VERIFY((size_t)freqBuf.size() == (size_t)nfft);
VERIFY( T(fft_rmse(freqBuf,tbuf)) < test_precision<T>() );// gross check VERIFY(T(fft_rmse(freqBuf, tbuf)) < test_precision<T>()); // gross check
if (nfft&1) if (nfft & 1) return; // odd FFTs get the wrong size inverse FFT
return; // odd FFTs get the wrong size inverse FFT
ScalarVector tbuf2; ScalarVector tbuf2;
fft.inv( tbuf2 , freqBuf); fft.inv(tbuf2, freqBuf);
VERIFY( T(dif_rmse(tbuf,tbuf2)) < test_precision<T>() );// gross check VERIFY(T(dif_rmse(tbuf, tbuf2)) < test_precision<T>()); // gross check
// verify that the Unscaled flag takes effect
ScalarVector tbuf3;
fft.SetFlag(fft.Unscaled);
// verify that the Unscaled flag takes effect fft.inv(tbuf3, freqBuf);
ScalarVector tbuf3;
fft.SetFlag(fft.Unscaled);
fft.inv( tbuf3 , freqBuf); for (int k = 0; k < nfft; ++k) tbuf3[k] *= T(1. / nfft);
for (int k=0;k<nfft;++k) // for (size_t i=0;i<(size_t) tbuf.size();++i)
tbuf3[k] *= T(1./nfft); // cout << "freqBuf=" << freqBuf[i] << " in2=" << tbuf3[i] << " - in=" << tbuf[i] << " => " << (tbuf3[i] -
// tbuf[i] ) << endl;
VERIFY(T(dif_rmse(tbuf, tbuf3)) < test_precision<T>()); // gross check
//for (size_t i=0;i<(size_t) tbuf.size();++i) // verify that ClearFlag works
// cout << "freqBuf=" << freqBuf[i] << " in2=" << tbuf3[i] << " - in=" << tbuf[i] << " => " << (tbuf3[i] - tbuf[i] ) << endl; fft.ClearFlag(fft.Unscaled);
fft.inv(tbuf2, freqBuf);
VERIFY( T(dif_rmse(tbuf,tbuf3)) < test_precision<T>() );// gross check VERIFY(T(dif_rmse(tbuf, tbuf2)) < test_precision<T>()); // gross check
// verify that ClearFlag works
fft.ClearFlag(fft.Unscaled);
fft.inv( tbuf2 , freqBuf);
VERIFY( T(dif_rmse(tbuf,tbuf2)) < test_precision<T>() );// gross check
} }
template <typename T> template <typename T>
void test_scalar(int nfft) void test_scalar(int nfft) {
{ test_scalar_generic<StdVectorContainer, T>(nfft);
test_scalar_generic<StdVectorContainer,T>(nfft); // test_scalar_generic<EigenVectorContainer,T>(nfft);
//test_scalar_generic<EigenVectorContainer,T>(nfft);
} }
template <int Container, typename T> template <int Container, typename T>
void test_complex_generic(int nfft) void test_complex_generic(int nfft) {
{ typedef typename FFT<T>::Complex Complex;
typedef typename FFT<T>::Complex Complex; typedef typename VectorType<Container, Complex>::type ComplexVector;
typedef typename VectorType<Container,Complex>::type ComplexVector;
FFT<T> fft; FFT<T> fft;
ComplexVector inbuf(nfft); ComplexVector inbuf(nfft);
ComplexVector outbuf; ComplexVector outbuf;
ComplexVector buf3; ComplexVector buf3;
for (int k=0;k<nfft;++k) for (int k = 0; k < nfft; ++k)
inbuf[k]= Complex( (T)(rand()/(double)RAND_MAX - .5), (T)(rand()/(double)RAND_MAX - .5) ); inbuf[k] = Complex((T)(rand() / (double)RAND_MAX - .5), (T)(rand() / (double)RAND_MAX - .5));
fft.fwd( outbuf , inbuf); fft.fwd(outbuf, inbuf);
VERIFY( T(fft_rmse(outbuf,inbuf)) < test_precision<T>() );// gross check VERIFY(T(fft_rmse(outbuf, inbuf)) < test_precision<T>()); // gross check
fft.inv( buf3 , outbuf); fft.inv(buf3, outbuf);
VERIFY( T(dif_rmse(inbuf,buf3)) < test_precision<T>() );// gross check VERIFY(T(dif_rmse(inbuf, buf3)) < test_precision<T>()); // gross check
// verify that the Unscaled flag takes effect // verify that the Unscaled flag takes effect
ComplexVector buf4; ComplexVector buf4;
fft.SetFlag(fft.Unscaled); fft.SetFlag(fft.Unscaled);
fft.inv( buf4 , outbuf); fft.inv(buf4, outbuf);
for (int k=0;k<nfft;++k) for (int k = 0; k < nfft; ++k) buf4[k] *= T(1. / nfft);
buf4[k] *= T(1./nfft); VERIFY(T(dif_rmse(inbuf, buf4)) < test_precision<T>()); // gross check
VERIFY( T(dif_rmse(inbuf,buf4)) < test_precision<T>() );// gross check
// verify that ClearFlag works // verify that ClearFlag works
fft.ClearFlag(fft.Unscaled); fft.ClearFlag(fft.Unscaled);
fft.inv( buf3 , outbuf); fft.inv(buf3, outbuf);
VERIFY( T(dif_rmse(inbuf,buf3)) < test_precision<T>() );// gross check VERIFY(T(dif_rmse(inbuf, buf3)) < test_precision<T>()); // gross check
} }
template <typename T> template <typename T>
void test_complex(int nfft) void test_complex(int nfft) {
{ test_complex_generic<StdVectorContainer, T>(nfft);
test_complex_generic<StdVectorContainer,T>(nfft); test_complex_generic<EigenVectorContainer, T>(nfft);
test_complex_generic<EigenVectorContainer,T>(nfft);
} }
template <typename T,int nrows,int ncols> template <typename T, int nrows, int ncols>
void test_complex2d() void test_complex2d() {
{ typedef typename Eigen::FFT<T>::Complex Complex;
typedef typename Eigen::FFT<T>::Complex Complex; FFT<T> fft;
FFT<T> fft; Eigen::Matrix<Complex, nrows, ncols> src, src2, dst, dst2;
Eigen::Matrix<Complex,nrows,ncols> src,src2,dst,dst2;
src = Eigen::Matrix<Complex,nrows,ncols>::Random(); src = Eigen::Matrix<Complex, nrows, ncols>::Random();
//src = Eigen::Matrix<Complex,nrows,ncols>::Identity(); // src = Eigen::Matrix<Complex,nrows,ncols>::Identity();
for (int k=0;k<ncols;k++) { for (int k = 0; k < ncols; k++) {
Eigen::Matrix<Complex,nrows,1> tmpOut; Eigen::Matrix<Complex, nrows, 1> tmpOut;
fft.fwd( tmpOut,src.col(k) ); fft.fwd(tmpOut, src.col(k));
dst2.col(k) = tmpOut; dst2.col(k) = tmpOut;
} }
for (int k=0;k<nrows;k++) { for (int k = 0; k < nrows; k++) {
Eigen::Matrix<Complex,1,ncols> tmpOut; Eigen::Matrix<Complex, 1, ncols> tmpOut;
fft.fwd( tmpOut, dst2.row(k) ); fft.fwd(tmpOut, dst2.row(k));
dst2.row(k) = tmpOut; dst2.row(k) = tmpOut;
} }
fft.fwd2(dst.data(),src.data(),ncols,nrows); fft.fwd2(dst.data(), src.data(), ncols, nrows);
fft.inv2(src2.data(),dst.data(),ncols,nrows); fft.inv2(src2.data(), dst.data(), ncols, nrows);
VERIFY( (src-src2).norm() < test_precision<T>() ); VERIFY((src - src2).norm() < test_precision<T>());
VERIFY( (dst-dst2).norm() < test_precision<T>() ); VERIFY((dst - dst2).norm() < test_precision<T>());
} }
void test_return_by_value(int len) inline void test_return_by_value(int len) {
{ VectorXf in;
VectorXf in; VectorXf in1;
VectorXf in1; in.setRandom(len);
in.setRandom( len ); VectorXcf out1, out2;
VectorXcf out1,out2; FFT<float> fft;
FFT<float> fft;
fft.SetFlag(fft.HalfSpectrum ); fft.SetFlag(fft.HalfSpectrum);
fft.fwd(out1,in); fft.fwd(out1, in);
out2 = fft.fwd(in); out2 = fft.fwd(in);
VERIFY( (out1-out2).norm() < test_precision<float>() ); VERIFY((out1 - out2).norm() < test_precision<float>());
in1 = fft.inv(out1); in1 = fft.inv(out1);
VERIFY( (in1-in).norm() < test_precision<float>() ); VERIFY((in1 - in).norm() < test_precision<float>());
} }
EIGEN_DECLARE_TEST(FFTW) EIGEN_DECLARE_TEST(FFTW) {
{ CALL_SUBTEST(test_return_by_value(32));
CALL_SUBTEST( test_return_by_value(32) ); CALL_SUBTEST(test_complex<float>(32));
CALL_SUBTEST( test_complex<float>(32) ); CALL_SUBTEST( test_complex<double>(32) ); CALL_SUBTEST(test_complex<double>(32));
CALL_SUBTEST( test_complex<float>(256) ); CALL_SUBTEST( test_complex<double>(256) ); CALL_SUBTEST(test_complex<float>(256));
CALL_SUBTEST( test_complex<float>(3*8) ); CALL_SUBTEST( test_complex<double>(3*8) ); CALL_SUBTEST(test_complex<double>(256));
CALL_SUBTEST( test_complex<float>(5*32) ); CALL_SUBTEST( test_complex<double>(5*32) ); CALL_SUBTEST(test_complex<float>(3 * 8));
CALL_SUBTEST( test_complex<float>(2*3*4) ); CALL_SUBTEST( test_complex<double>(2*3*4) ); CALL_SUBTEST(test_complex<double>(3 * 8));
CALL_SUBTEST( test_complex<float>(2*3*4*5) ); CALL_SUBTEST( test_complex<double>(2*3*4*5) ); CALL_SUBTEST(test_complex<float>(5 * 32));
CALL_SUBTEST( test_complex<float>(2*3*4*5*7) ); CALL_SUBTEST( test_complex<double>(2*3*4*5*7) ); CALL_SUBTEST(test_complex<double>(5 * 32));
CALL_SUBTEST(test_complex<float>(2 * 3 * 4));
CALL_SUBTEST(test_complex<double>(2 * 3 * 4));
CALL_SUBTEST(test_complex<float>(2 * 3 * 4 * 5));
CALL_SUBTEST(test_complex<double>(2 * 3 * 4 * 5));
CALL_SUBTEST(test_complex<float>(2 * 3 * 4 * 5 * 7));
CALL_SUBTEST(test_complex<double>(2 * 3 * 4 * 5 * 7));
CALL_SUBTEST( test_scalar<float>(32) ); CALL_SUBTEST( test_scalar<double>(32) ); CALL_SUBTEST(test_scalar<float>(32));
CALL_SUBTEST( test_scalar<float>(45) ); CALL_SUBTEST( test_scalar<double>(45) ); CALL_SUBTEST(test_scalar<double>(32));
CALL_SUBTEST( test_scalar<float>(50) ); CALL_SUBTEST( test_scalar<double>(50) ); CALL_SUBTEST(test_scalar<float>(45));
CALL_SUBTEST( test_scalar<float>(256) ); CALL_SUBTEST( test_scalar<double>(256) ); CALL_SUBTEST(test_scalar<double>(45));
CALL_SUBTEST( test_scalar<float>(2*3*4*5*7) ); CALL_SUBTEST( test_scalar<double>(2*3*4*5*7) ); CALL_SUBTEST(test_scalar<float>(50));
CALL_SUBTEST(test_scalar<double>(50));
#if defined EIGEN_HAS_FFTWL || defined EIGEN_POCKETFFT_DEFAULT CALL_SUBTEST(test_scalar<float>(256));
CALL_SUBTEST( test_complex<long double>(32) ); CALL_SUBTEST(test_scalar<double>(256));
CALL_SUBTEST( test_complex<long double>(256) ); CALL_SUBTEST(test_scalar<float>(2 * 3 * 4 * 5 * 7));
CALL_SUBTEST( test_complex<long double>(3*8) ); CALL_SUBTEST(test_scalar<double>(2 * 3 * 4 * 5 * 7));
CALL_SUBTEST( test_complex<long double>(5*32) );
CALL_SUBTEST( test_complex<long double>(2*3*4) );
CALL_SUBTEST( test_complex<long double>(2*3*4*5) );
CALL_SUBTEST( test_complex<long double>(2*3*4*5*7) );
CALL_SUBTEST( test_scalar<long double>(32) );
CALL_SUBTEST( test_scalar<long double>(45) );
CALL_SUBTEST( test_scalar<long double>(50) );
CALL_SUBTEST( test_scalar<long double>(256) );
CALL_SUBTEST( test_scalar<long double>(2*3*4*5*7) );
CALL_SUBTEST( ( test_complex2d<long double, 2*3*4, 2*3*4> () ) ); #if defined EIGEN_HAS_FFTWL || defined EIGEN_POCKETFFT_DEFAULT
CALL_SUBTEST( ( test_complex2d<long double, 3*4*5, 3*4*5> () ) ); CALL_SUBTEST(test_complex<long double>(32));
CALL_SUBTEST( ( test_complex2d<long double, 24, 60> () ) ); CALL_SUBTEST(test_complex<long double>(256));
CALL_SUBTEST( ( test_complex2d<long double, 60, 24> () ) ); CALL_SUBTEST(test_complex<long double>(3 * 8));
// fail to build since Eigen limit the stack allocation size,too big here. CALL_SUBTEST(test_complex<long double>(5 * 32));
// CALL_SUBTEST( ( test_complex2d<long double, 256, 256> () ) ); CALL_SUBTEST(test_complex<long double>(2 * 3 * 4));
#endif CALL_SUBTEST(test_complex<long double>(2 * 3 * 4 * 5));
#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_MKL_DEFAULT CALL_SUBTEST(test_complex<long double>(2 * 3 * 4 * 5 * 7));
CALL_SUBTEST( ( test_complex2d<float, 24, 24> () ) );
CALL_SUBTEST( ( test_complex2d<float, 60, 60> () ) ); CALL_SUBTEST(test_scalar<long double>(32));
CALL_SUBTEST( ( test_complex2d<float, 24, 60> () ) ); CALL_SUBTEST(test_scalar<long double>(45));
CALL_SUBTEST( ( test_complex2d<float, 60, 24> () ) ); CALL_SUBTEST(test_scalar<long double>(50));
CALL_SUBTEST(test_scalar<long double>(256));
CALL_SUBTEST(test_scalar<long double>(2 * 3 * 4 * 5 * 7));
CALL_SUBTEST((test_complex2d<long double, 2 * 3 * 4, 2 * 3 * 4>()));
CALL_SUBTEST((test_complex2d<long double, 3 * 4 * 5, 3 * 4 * 5>()));
CALL_SUBTEST((test_complex2d<long double, 24, 60>()));
CALL_SUBTEST((test_complex2d<long double, 60, 24>()));
// fail to build since Eigen limit the stack allocation size,too big here.
// CALL_SUBTEST( ( test_complex2d<long double, 256, 256> () ) );
#endif #endif
#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_MKL_DEFAULT #if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_MKL_DEFAULT
CALL_SUBTEST( ( test_complex2d<double, 24, 24> () ) ); CALL_SUBTEST((test_complex2d<float, 24, 24>()));
CALL_SUBTEST( ( test_complex2d<double, 60, 60> () ) ); CALL_SUBTEST((test_complex2d<float, 60, 60>()));
CALL_SUBTEST( ( test_complex2d<double, 24, 60> () ) ); CALL_SUBTEST((test_complex2d<float, 24, 60>()));
CALL_SUBTEST( ( test_complex2d<double, 60, 24> () ) ); CALL_SUBTEST((test_complex2d<float, 60, 24>()));
#endif #endif
#if defined EIGEN_FFTW_DEFAULT || defined EIGEN_POCKETFFT_DEFAULT || defined EIGEN_MKL_DEFAULT
CALL_SUBTEST((test_complex2d<double, 24, 24>()));
CALL_SUBTEST((test_complex2d<double, 60, 60>()));
CALL_SUBTEST((test_complex2d<double, 24, 60>()));
CALL_SUBTEST((test_complex2d<double, 60, 24>()));
#endif
} }