/* ======================================================================== */
/* TEXAS INSTRUMENTS, INC. */
/* */
/* NAME */
/* DSPF_sp_cfftr4_dif -- sp_cfftr4_dif */
/* */
/* USAGE */
/* */
/* This routine is C Callable and can be called as: */
/* */
/* void DSPF_sp_cfftr4_dif(float* x, float* w, short n) */
/* */
/* x : Pointer to an array holding the input and output floating */
/* point array which contains 'n' complex points */
/* w : Pointer to an array holding the coefficient floating point */
/* array which contains 3*n/4 complex numbers */
/* n : Number of complex points in x */
/* */
/* */
/* DESCRIPTION */
/* */
/* This routine implements the DIF (decimation in frequency) */
/* complex radix 4 FFT with digit-reversed output and normal */
/* order input. The number of points, 'n', must be a power */
/* of 4 {4, 16, 64, 256, 1024, ...}. This routine is an */
/* in-place routine in the sense that the output is written */
/* over the input. It is not an in-place routine in the */
/* sense that the input is in normal order and the output is */
/* in digit-reversed order. */
/* */
/* There must be n complex points (2*n values), and 3*n/4 complex */
/* coefficients (3*n/2 values). */
/* */
/* Each real and imaginary input value is interleaved in the */
/* 'x' array {rx0, ix0, rx1, ix2, ...} and the complex numbers */
/* are in normal order. Each real and imaginary output value */
/* is interleaved in the 'x' array and the complex numbers are */
/* in digit-reversed order {rx0, ix0, ...}. The real and */
/* imaginary values of the coefficients are interleaved in the */
/* 'w' array {rw0, -iw0, rw1, -iw1, ...} and the complex numbers */
/* are in normal order. */
/* */
/* Note that the imaginary coefficients are negated */
/* {cos(d*0), sin(d*0), cos(d*1), sin(d*1), ...} rather than */
/* {cos(d*0), -sin(d*0), cos(d*1), -sin(d*1), ...} */
/* where d = 2*PI/n. The value of w(n,k) is usually written */
/* w(n,k) = e^-j(2*PI*k/n) = cos(2*PI*k/n) - sin(2*PI*k/n). */
/* */
/* The routine can be used to implement an inverse FFT by */
/* performing the complex conjugate on the input complex numbers */
/* (negating the imaginary value), and dividing the result by n. */
/* Another method to use the FFT to perform an inverse FFT, is to */
/* swap the real and imaginary values of the input and the result, */
/* and divide the result by n. In either case, the input is still */
/* in normal order and the output is still in digit-reversed order. */
/* */
/* Note that you can not make the radix 4 FFT into an inverse */
/* FFT by using the complex conjugate of the coefficients as */
/* you can do with the complex radix 2 FFT. */
/* */
/* If you label the input locations from 0 to (n-1) (normal order), */
/* the digit-reversed locations can be calculated by reversing the */
/* order of the bit pairs of the labels. For example, for a 1024 */
/* point FFT, the digit reversed location for */
/* 617d = 1001101001b = 10 01 10 10 01 is */
/* 422d = 0110100110b = 01 10 10 01 10 and visa versa. */
/* */
/* ------------------------------------------------------------------------ */
/* Copyright (c) 2003 Texas Instruments, Incorporated. */
/* All Rights Reserved. */
/* ======================================================================== */
#ifndef DSPF_SP_CFFTR4_DIF_
#define DSPF_SP_CFFTR4_DIF_ 1
void DSPF_sp_cfftr4_dif(float * x, float * w, short n);
#endif
/* ======================================================================== */
/* End of file: dspf_sp_cfftr4_dif.h */
/* ------------------------------------------------------------------------ */
/* Copyright (C) 2003 Texas Instruments, Incorporated. */
/* All Rights Reserved. */
/* ======================================================================== */