doc/examples/FFT.cpp File Reference

#include <vector>
#include <complex>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <Eigen/Core>
#include <unsupported/Eigen/FFT>

Functions
template<typename T >
T	mag2 (T a)
template<typename T >
T	mag2 (std::complex< T > a)
template<typename T >
T	mag2 (const std::vector< T > &vec)
template<typename T >
T	mag2 (const std::vector< std::complex< T > > &vec)
template<typename T >
vector< T >	operator- (const vector< T > &a, const vector< T > &b)
template<typename T >
void	RandomFill (std::vector< T > &vec)
template<typename T >
void	RandomFill (std::vector< std::complex< T > > &vec)
template<typename T_time , typename T_freq >
void	fwd_inv (size_t nfft)
template<typename T_scalar >
void	two_demos (int nfft)
void	demo_all_types (int nfft)
int	main ()

Function Documentation

demo_all_types()

void demo_all_types

(

int

nfft

)

                              {
  cout << "nfft=" << nfft << endl;
  cout << "   float" << endl;
  two_demos<float>(nfft);
  cout << "   double" << endl;
  two_demos<double>(nfft);
  cout << "   long double" << endl;
  two_demos<long double>(nfft);
}

Referenced by main().

fwd_inv()

template<typename T_time , typename T_freq >

void fwd_inv

(

size_t

nfft

)

                          {
  typedef typename NumTraits<T_freq>::Real Scalar;
  vector<T_time> timebuf(nfft);
  RandomFill(timebuf);
 
  vector<T_freq> freqbuf;
  static FFT<Scalar> fft;
  fft.fwd(freqbuf, timebuf);
 
  vector<T_time> timebuf2;
  fft.inv(timebuf2, freqbuf);
 
  T_time rmse = mag2(timebuf - timebuf2) / mag2(timebuf);
  cout << "roundtrip rmse: " << rmse << endl;
}

References mag2(), and RandomFill().

mag2() [1/4]

template<typename T >

T mag2

(

const std::vector< std::complex< T > > &

vec

)

                                             {
  T out = 0;
  for (size_t k = 0; k < vec.size(); ++k) out += mag2(vec[k]);
  return out;
}

References k, mag2(), and out().

mag2() [2/4]

template<typename T >

T mag2

(

const std::vector< T > &

vec

)

                                {
  T out = 0;
  for (size_t k = 0; k < vec.size(); ++k) out += mag2(vec[k]);
  return out;
}

References k, mag2(), and out().

mag2() [3/4]

template<typename T >

T mag2

(

std::complex< T >

a

)

                        {
  return norm(a);
}

References a.

mag2() [4/4]

template<typename T >

T mag2

(

T

a

)

            {
  return a * a;
}

References a.

Referenced by fwd_inv(), and mag2().

main()

int main

(

)

           {
  demo_all_types(2 * 3 * 4 * 5 * 7);
  demo_all_types(2 * 9 * 16 * 25);
  demo_all_types(1024);
  return 0;
}

References demo_all_types().

operator-()

template<typename T >

vector<T> operator-	(	const vector< T > &	a,
		const vector< T > &	b
	)

                                                            {
  vector<T> c(a);
  for (size_t k = 0; k < b.size(); ++k) c[k] -= b[k];
  return c;
}

References a, b, calibrate::c, and k.

RandomFill() [1/2]

template<typename T >

void RandomFill

(

std::vector< std::complex< T > > &

vec

)

                                                {
  for (size_t k = 0; k < vec.size(); ++k)
    vec[k] = std::complex<T>(T(rand()) / T(RAND_MAX) - T(.5), T(rand()) / T(RAND_MAX) - T(.5));
}

References k.

RandomFill() [2/2]

template<typename T >

void RandomFill

(

std::vector< T > &

vec

)

                                   {
  for (size_t k = 0; k < vec.size(); ++k) vec[k] = T(rand()) / T(RAND_MAX) - T(.5);
}

References k.

Referenced by fwd_inv().

two_demos()

template<typename T_scalar >

void two_demos

(

int

nfft

)

                         {
  cout << "     scalar ";
  fwd_inv<T_scalar, std::complex<T_scalar> >(nfft);
  cout << "    complex ";
  fwd_inv<std::complex<T_scalar>, std::complex<T_scalar> >(nfft);
}