fft Namespace Reference

Typedefs
typedef float	real_type
typedef std::complex< real_type >	complex_type

Functions
bool	fft_adc_sample (float *w, float ratio, float sensitivity, const adcsample_t *data_in, complex_type *data_out, const size_t size)
bool	fft_adc_sample_filtered (Biquad &knockFilter, float *w, float ratio, float sensitivity, const adcsample_t *data_in, complex_type *data_out, const size_t size)
bool	fft (const real_type *data_in, complex_type *data_out, const size_t size)
void	rectwin (float *w, unsigned n)
void	hann (float *w, unsigned n, bool sflag)
void	hamming (float *w, unsigned n, bool sflag)
void	blackman (float *w, unsigned n, bool sflag)
void	blackmanharris (float *w, unsigned n, bool sflag)
float	fast_sqrt (float x)
float	amplitude (const complex_type &fft)
bool	isPow (const size_t num)
void	rerrange (complex_type *data, const size_t num_elements)
bool	transform (complex_type *data, const size_t count)
static bool	ffti (complex_type *data, const size_t size)
void	cosine_window (float *w, unsigned n, const float *coeff, unsigned ncoeff, bool sflag)

Typedef Documentation

complex_type

typedef std::complex<real_type> fft::complex_type

Definition at line 17 of file fft.h.

real_type

typedef float fft::real_type

Definition at line 16 of file fft.h.

Function Documentation

amplitude()

float fft::amplitude

(

const complex_type &

fft

)

Definition at line 133 of file fft.hpp.

                                         {
    return fast_sqrt(fft.real()*fft.real() + fft.imag()*fft.imag());
}

Referenced by processLastKnockEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

blackman()

void fft::blackman	(	float *	w,
		unsigned	n,
		bool	sflag
	)

Definition at line 182 of file fft.hpp.

{
    const float coeff[3] = { 0.42, -0.5, 0.08 };
    cosine_window(w, n, coeff, sizeof(coeff) / sizeof(float), sflag);
}

Here is the call graph for this function:

blackmanharris()

void fft::blackmanharris	(	float *	w,
		unsigned	n,
		bool	sflag
	)

Definition at line 188 of file fft.hpp.

{
    const float coeff[4] = { 0.35875, -0.48829, 0.14128, -0.01168 };
    cosine_window(w, n, coeff, sizeof(coeff) / sizeof(float), sflag);
}

Referenced by initSoftwareKnock().

Here is the call graph for this function:

Here is the caller graph for this function:

cosine_window()

void fft::cosine_window	(	float *	w,
		unsigned	n,
		const float *	coeff,
		unsigned	ncoeff,
		bool	sflag
	)

Definition at line 137 of file fft.hpp.

{
    if (n == 1)
    {
        w[0] = 1.0;
    }
    else
    {
        const unsigned wlength = sflag ? (n - 1) : n;
 
        for (unsigned i = 0; i < n; ++i)
        {
            float wi = 0.0;
 
            for (unsigned j = 0; j < ncoeff; ++j)
            {
                wi += coeff[j] * cos(i * j * 2.0 * M_PI / wlength);
            }
 
            w[i] = wi;
        }
    }
}

Referenced by blackman(), blackmanharris(), hamming(), and hann().

Here is the caller graph for this function:

fast_sqrt()

float fft::fast_sqrt

(

float

x

)

Definition at line 119 of file fft.hpp.

                         {
  union
  {
    float x;
    int32_t i;
  } u;
  u.x = x;
  u.i = 0x5f375a86 - (u.i >> 1);
  float xu = x * u.x;
  float xu2 = xu * u.x;
  u.x = (0.125 * 3.0) * xu * (5.0 - xu2 * ((10.0 / 3.0) - xu2));
  return u.x;
}

Referenced by amplitude().

Here is the caller graph for this function:

fft()

bool fft::fft	(	const real_type *	data_in,
		complex_type *	data_out,
		const size_t	size
	)

Definition at line 109 of file fft.hpp.

{
    for(size_t i = 0; i < size; ++i) {
        data_out[i] = complex_type(data_in[i], 0.0);
    }
 
    return ffti(data_out, size);
}

Here is the call graph for this function:

fft_adc_sample()

bool fft::fft_adc_sample	(	float *	w,
		float	ratio,
		float	sensitivity,
		const adcsample_t *	data_in,
		complex_type *	data_out,
		const size_t	size
	)

Definition at line 88 of file fft.hpp.

{
    for(size_t i = 0; i < size; ++i) {
        float voltage = ratio * data_in[i];
        data_out[i] = complex_type(sensitivity * voltage * w[i], 0.0);
    }
 
    return ffti(data_out, size);
}

Referenced by processLastKnockEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

fft_adc_sample_filtered()

bool fft::fft_adc_sample_filtered	(	Biquad &	knockFilter,
		float *	w,
		float	ratio,
		float	sensitivity,
		const adcsample_t *	data_in,
		complex_type *	data_out,
		const size_t	size
	)

Definition at line 98 of file fft.hpp.

{
    for(size_t i = 0; i < size; ++i) {
        float voltage = ratio * data_in[i];
        float filtered = knockFilter.filter(voltage);
        data_out[i] = complex_type(filtered * w[i] * sensitivity, 0.0);
    }
 
    return ffti(data_out, size);
}

Referenced by processLastKnockEvent().

Here is the call graph for this function:

Here is the caller graph for this function:

ffti()

static bool fft::ffti ( complex_type *  data, const size_t  size  )

static

Definition at line 77 of file fft.hpp.

{
    if(!isPow(size)) {
        return false;
    }
 
    rerrange(data, size);
 
    return transform(data, size);
}

Referenced by fft(), fft_adc_sample(), and fft_adc_sample_filtered().

Here is the call graph for this function:

Here is the caller graph for this function:

hamming()

void fft::hamming	(	float *	w,
		unsigned	n,
		bool	sflag
	)

Definition at line 176 of file fft.hpp.

{
    const float coeff[2] = { 0.54, -0.46 };
    cosine_window(w, n, coeff, sizeof(coeff) / sizeof(float), sflag);
}

Here is the call graph for this function:

hann()

void fft::hann	(	float *	w,
		unsigned	n,
		bool	sflag
	)

Definition at line 169 of file fft.hpp.

{
    const float coeff[2] = { 0.5, -0.5 };
 
    cosine_window(w, n, coeff, sizeof(coeff) / sizeof(float), sflag);
}

Here is the call graph for this function:

isPow()

bool fft::isPow ( const size_t  num )

inline

Definition at line 10 of file fft.hpp.

{
    return num && (!(num & (num - 1)));
}

Referenced by ffti().

Here is the caller graph for this function:

rectwin()

void fft::rectwin	(	float *	w,
		unsigned	n
	)

Definition at line 161 of file fft.hpp.

{
    for (unsigned i = 0; i < n; ++i)
    {
        w[i] = 1.0;
    }
}

rerrange()

void fft::rerrange	(	complex_type *	data,
		const size_t	num_elements
	)

Definition at line 15 of file fft.hpp.

{
    size_t target_index = 0;
    size_t bit_mask;
 
    complex_type buffer;
    for (size_t i = 0; i < num_elements; ++i)
    {
        if (target_index > i)
        {
            buffer = data[target_index];
            data[target_index] = data[i];
            data[i]= buffer;
        }
 
        bit_mask = num_elements;
 
        while (target_index & (bit_mask >>= 1))
        {
            target_index &= ~bit_mask;
        }
 
        target_index |= bit_mask;
    }
}

Referenced by ffti().

Here is the caller graph for this function:

transform()

bool fft::transform	(	complex_type *	data,
		const size_t	count
	)

Definition at line 41 of file fft.hpp.

{
    double local_pi = -M_PI;
 
    size_t next, match;
    real_type sine;
    real_type delta;
    complex_type mult, factor, product;
 
    for (size_t i = 1; i < count; i <<= 1)
    {
        next = i << 1;
        delta = local_pi / i;
        sine = sin(0.5 * delta);
 
        mult = complex_type(-2.0 * sine * sine, sin(delta));
        factor = 1.0;
 
        for (size_t j = 0; j < i; ++j)
        {
            for (size_t k = j; k < count; k += next)
            {
                match = k + i;
 
                product = data[match] * factor;
                data[match] = data[k] - product;
                data[k] += product;
            }
 
            factor = mult * factor + factor;
        }
    }
 
    return true;
}

Referenced by ffti().

Here is the caller graph for this function: