def inverse_hermite_fft(a, n=None, axis=-1):
"""hermite_fft(a, n=None, axis=-1)
inverse_hermite_fft(a, n=None, axis=-1)
These are a pair analogous to real_fft/inverse_real_fft, but for the
opposite case: here the signal is real in the frequency domain and has
Hermite symmetry in the time domain. So here it's hermite_fft for which
you must supply the length of the result if it is to be odd.
inverse_hermite_fft(hermite_fft(a), len(a)) == a
within numerical accuracy."""
a = num.asarray(a).astype(num.Float)
if n == None:
n = num.shape(a)[axis]
return num.conjugate(real_fft(a, n, axis)) / n
def inverse_hermite_fft(a, n=None, axis=-1):
"""hermite_fft(a, n=None, axis=-1)
inverse_hermite_fft(a, n=None, axis=-1)
These are a pair analogous to real_fft/inverse_real_fft, but for the
opposite case: here the signal is real in the frequency domain and has
Hermite symmetry in the time domain. So here it's hermite_fft for which
you must supply the length of the result if it is to be odd.
inverse_hermite_fft(hermite_fft(a), len(a)) == a
within numerical accuracy."""
a = num.asarray(a).astype(num.Float)
if n == None:
n = num.shape(a)[axis]
return num.conjugate(real_fft(a, n, axis))/n
def inverse_real_fft(a, n=None, axis=-1):
"""inverse_real_fft(a, n=None, axis=-1)
Will return the real valued n point inverse discrete Fourier transform of
a, where a contains the nonnegative frequency terms of a Hermite-symmetric
sequence. n is the length of the result, not the input. If n is not
supplied, the default is 2*(len(a)-1). If you want the length of the
result to be odd, you have to say so.
If you specify an n such that a must be zero-padded or truncated, the
extra/removed values will be added/removed at high frequencies. One can
thus resample a series to m points via Fourier interpolation by: a_resamp
= inverse_real_fft(real_fft(a), m).
This is the inverse of real_fft:
inverse_real_fft(real_fft(a), len(a)) == a
within numerical accuracy."""
a = num.asarray(a).astype(num.Complex)
if n == None:
n = (num.shape(a)[axis] - 1) * 2
return _raw_fft(a, n, axis, fftpack.rffti, fftpack.rfftb,
_real_fft_cache) / n
def inverse_fft(a, n=None, axis=-1):
"""inverse_fft(a, n=None, axis=-1)
Will return the n point inverse discrete Fourier transform of a. n
defaults to the length of a. If n is larger than a, then a will be
zero-padded to make up the difference. If n is smaller than a, then a will
be truncated to reduce its size.
The input array is expected to be packed the same way as the output of
fft, as discussed in it's documentation.
This is the inverse of fft: inverse_fft(fft(a)) == a within numerical
accuracy.
This is most efficient for n a power of two. This also stores a cache of
working memory for different sizes of fft's, so you could theoretically
run into memory problems if you call this too many times with too many
different n's."""
a = num.asarray(a).astype(num.Complex)
if n == None:
n = num.shape(a)[axis]
return _raw_fft(a, n, axis, fftpack.cffti, fftpack.cfftb, _fft_cache) / n
def inverse_fft(a, n=None, axis=-1):
"""inverse_fft(a, n=None, axis=-1)
Will return the n point inverse discrete Fourier transform of a. n
defaults to the length of a. If n is larger than a, then a will be
zero-padded to make up the difference. If n is smaller than a, then a will
be truncated to reduce its size.
The input array is expected to be packed the same way as the output of
fft, as discussed in it's documentation.
This is the inverse of fft: inverse_fft(fft(a)) == a within numerical
accuracy.
This is most efficient for n a power of two. This also stores a cache of
working memory for different sizes of fft's, so you could theoretically
run into memory problems if you call this too many times with too many
different n's."""
a = num.asarray(a).astype(num.Complex)
if n == None:
n = num.shape(a)[axis]
return _raw_fft(a, n, axis, fftpack.cffti, fftpack.cfftb, _fft_cache) / n
def inverse_real_fft(a, n=None, axis=-1):
"""inverse_real_fft(a, n=None, axis=-1)
Will return the real valued n point inverse discrete Fourier transform of
a, where a contains the nonnegative frequency terms of a Hermite-symmetric
sequence. n is the length of the result, not the input. If n is not
supplied, the default is 2*(len(a)-1). If you want the length of the
result to be odd, you have to say so.
If you specify an n such that a must be zero-padded or truncated, the
extra/removed values will be added/removed at high frequencies. One can
thus resample a series to m points via Fourier interpolation by: a_resamp
= inverse_real_fft(real_fft(a), m).
This is the inverse of real_fft:
inverse_real_fft(real_fft(a), len(a)) == a
within numerical accuracy."""
a = num.asarray(a).astype(num.Complex)
if n == None:
n = (num.shape(a)[axis] - 1) * 2
return _raw_fft(a, n, axis, fftpack.rffti, fftpack.rfftb,
_real_fft_cache) / n
