Time domain interpolation using FFT with zero padding on the end I've got a situation where I'd like to use an FFT to do interpolation in time on some complex data (I need to go to the frequency domain anyways to window my data).  

The notional way of doing this is to take an FFT, which, in the case of something like FFTW will put the frequency components "in-order" which can be viewed as having positive frequencies first, followed by negative.

$\mathcal{F}([\begin{array}{ccccccc} a &amp; b &amp; c &amp; d &amp; e &amp; f &amp; g &amp; h \end{array}]) = \begin{array}{cccccccc} [A &amp; B &amp; C &amp; D &amp; E &amp; F &amp; G &amp; H] \end{array}$

Where ABCD are positive frequency components, and EFGH are negative frequency components.

You can split the frequency response in two and zero-pad between D and E, but you have to be careful if your transform is an odd length, as well as possibly splitting the nyquist bin, and it's more cumbersome from a buffer-juggling perspective too.  It'd be better if I could pre-multiply by Fs/2, which will rotate the spectrum:

$\mathcal{F}(exp(j2\pi fs/2t) * [\begin{array}{ccccccc} a &amp; b &amp; c &amp; d &amp; e &amp; f &amp; g &amp; h \end{array}]) = \begin{array}{cccccccc} [E &amp; F &amp; G &amp; H &amp; A &amp; B &amp; C &amp; D] \end{array}$

Then it's just a matter of zero padding on the end, and getting back to the time domain.  This might be as simple as just transforming into a sufficiently large zeroed buffer.

But, it's the getting back to the time domain that's got me wrapped around the axle.  You can certainly inverse-FFT, and then multiply by -Fs/4 to shift things back to the way they should be, but I'd prefer to avoid the post-multiplication if I can (performance reasons).

My gut says that the shifted spectrum is now in the proper order (again in FFTW land) to just do a forward-FFT on it, but that might time-reverse the data, so perhaps a conjugate before transforming would be in order, but I'm not sure.  Can anyone help me puzzle this out?
It's important to remember that, for an even N, you have both F(0) and F(N/2) points, neither of which has a counterpart.  So, for instance, with N = 8, you have:

F(0),  F(1),  F(2),  F(3),  F(4),  F(-3),  F(-2),  F(-1)

(some people consider the N/2 point as a negative frequency ( ie: F(-4) ), but we'll consider it to be positive)

So to interpolate an 8 point FFT by a factor of 2, you'd do a 16 point inverse FFT using:

F(0),  F(1),  F(2),  F(3),  F(4)/2,  0,  0,  0,  0,  0,  0,  0,  F(4)/2,  F(-3),  F(-2),  F(-1)

So you split the N/2 point of your forward FFT, and add the appropriate number of zeroes in the center, and do the inverse.

Now, for an odd number N, you DON'T have an N/2 point (but you still have a unique 0 point), and the splitting business doesn't happen (but you still have to add the appropriate zeroes in the center).

I suggest you experiment with the FFT/IFFT method by using: a real input time domain waveform; a complex input time domain waveform; even and odd N; an integer number of cycles in the input; a non-integer number of cycles in the input.  Then compare/contrast your results from the FFT/IFFT method with to those generated by a strictly time domain based interpolation (eg: use A*cos(omega*t) for the FFT/IFFT method and compare to A*cos(omega*t/2) generated in the time domain).  Experience can be enlightening.

As for your multiplying method – I don't think it will work for an even N.  And the FFT/IFFT timing, unless you're using very small FFT's, will probably dominate the total run time (of, course, you should always profile your programs to make sure).