# Real-Only FFT

Started by June 2, 2013
```Hi DSP people,

Is there a way to do complex FFT (with imaginary components) with a real
only FFT alogarithm ? Thanks !

```
```On Jun 2, 8:05&#2013266080;pm, "rigor" <95223@dsprelated> wrote:
> Hi DSP people,
>
> Is there a way to do complex FFT (with imaginary components) with a real
> only FFT alogarithm ? Thanks !

uhm, we need to talk a bit about what you mean by a "real only FFT".

there are FFT programs that take N real values, x[n], going in and
tightly packed (no zero-padding the imaginary part) and returns N/2
complex values, X[k], where X[0] is packed with the real part of X[0]
and the real part of X[N/2] (the imaginary parts of those two
components are known to be zero for real x[n]).  for X[1] ... X[N/
2-1], these values are understood to have complex conjugates that are
not redundantly computed since x[n] is given as real.

now, you can do a complex FFT with that alg by running it twice, once
with the real part of x[n] and another with the imaginary part of
x[n].  combining the outputs is no sweat.  but here's the dumb thing
about it:  normally these real-input FFTs (i would not call it "real
only" FFT) are *built* outa a regular complex FFT of half the size.
so you separate the even-n samples of x[n] from the odd-n samples.
the former goes into the real part and the latter goes into the
imaginary part of N/2 complex samples and then you send that to a size
N/2 FFT and fix the output.

so you might already have a complex FFT that your real-only FFT is
using.

r b-j

```
```Hi r b-j,

Thanks !

I combine the outputs per the below and got the correct result. Is the
program I am having the real-input FFTs you called ?

A = fft(real(x))
B = fft(imaginary(x))
result = (real(A)-imaginary(B)) + i * (real(B)+imaginary(A))

```
```On Jun 3, 11:46&#2013266080;am, "rigor" <95223@dsprelated> wrote:
> Hi r b-j,
>
> Thanks !
>
> I combine the outputs per the below and got the correct result. Is the
> program I am having the real-input FFTs you called ?

i dunno, are you running MATLAB?

> A = fft(real(x))
> B = fft(imaginary(x))
> result = (real(A)-imaginary(B)) + i * (real(B)+imaginary(A))

... because in MATLAB, this should also work:

result = fft(x)

r b-j
```
```On Sun, 02 Jun 2013 19:05:40 -0500, "rigor" <95223@dsprelated> wrote:

>Hi DSP people,
>
>Is there a way to do complex FFT (with imaginary components) with a real
>only FFT alogarithm ? Thanks !
>

Hello rigor,
perhaps the following will be of use
to you:

http://www.dsprelated.com/showarticle/97.php

Good Luck,
[-Rick-]

```