# Python numpy.fft.ifft() Examples

The following are 30 code examples for showing how to use numpy.fft.ifft(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.

You may check out the related API usage on the sidebar.

You may also want to check out all available functions/classes of the module , or try the search function .

Example 1
 Project: lambda-packs   Author: ryfeus   File: fir_filter_design.py    License: MIT License 6 votes  def _dhtm(mag):
"""Compute the modified 1D discrete Hilbert transform

Parameters
----------
mag : ndarray
The magnitude spectrum. Should be 1D with an even length, and
preferably a fast length for FFT/IFFT.
"""
# Adapted based on code by Niranjan Damera-Venkata,
# Brian L. Evans and Shawn R. McCaslin (see refs for minimum_phase)
sig = np.zeros(len(mag))
# Leave Nyquist and DC at 0, knowing np.abs(fftfreq(N)[midpt]) == 0.5
midpt = len(mag) // 2
sig[1:midpt] = 1
sig[midpt+1:] = -1
# eventually if we want to support complex filters, we will need a
# np.abs() on the mag inside the log, and should remove the .real
recon = ifft(mag * np.exp(fft(sig * ifft(np.log(mag))))).real
return recon 
Example 2
 Project: vnpy_crypto   Author: birforce   File: fftarma.py    License: MIT License 6 votes  def filter(self, x):
'''
filter a timeseries with the ARMA filter

padding with zero is missing, in example I needed the padding to get
initial conditions identical to direct filter

Initial filtered observations differ from filter2 and signal.lfilter, but
at end they are the same.

--------
tsa.filters.fftconvolve

'''
n = x.shape
if n == self.fftarma:
fftarma = self.fftarma
else:
fftarma = self.fftma(n) / self.fftar(n)
tmpfft = fftarma * fft.fft(x)
return fft.ifft(tmpfft) 
Example 3
 Project: vnpy_crypto   Author: birforce   File: fftarma.py    License: MIT License 6 votes  def invpowerspd(self, n):
'''autocovariance from spectral density

scaling is correct, but n needs to be large for numerical accuracy
maybe padding with zero in fft would be faster
without slicing it returns 2-sided autocovariance with fftshift

>>> ArmaFft([1, -0.5], [1., 0.4], 40).invpowerspd(2**8)[:10]
array([ 2.08    ,  1.44    ,  0.72    ,  0.36    ,  0.18    ,  0.09    ,
0.045   ,  0.0225  ,  0.01125 ,  0.005625])
>>> ArmaFft([1, -0.5], [1., 0.4], 40).acovf(10)
array([ 2.08    ,  1.44    ,  0.72    ,  0.36    ,  0.18    ,  0.09    ,
0.045   ,  0.0225  ,  0.01125 ,  0.005625])
'''
hw = self.fftarma(n)
return np.real_if_close(fft.ifft(hw*hw.conj()), tol=200)[:n] 
Example 4
 Project: GraphicDesignPatternByPython   Author: Relph1119   File: fir_filter_design.py    License: MIT License 6 votes  def _dhtm(mag):
"""Compute the modified 1D discrete Hilbert transform

Parameters
----------
mag : ndarray
The magnitude spectrum. Should be 1D with an even length, and
preferably a fast length for FFT/IFFT.
"""
# Adapted based on code by Niranjan Damera-Venkata,
# Brian L. Evans and Shawn R. McCaslin (see refs for minimum_phase)
sig = np.zeros(len(mag))
# Leave Nyquist and DC at 0, knowing np.abs(fftfreq(N)[midpt]) == 0.5
midpt = len(mag) // 2
sig[1:midpt] = 1
sig[midpt+1:] = -1
# eventually if we want to support complex filters, we will need a
# np.abs() on the mag inside the log, and should remove the .real
recon = ifft(mag * np.exp(fft(sig * ifft(np.log(mag))))).real
return recon 
Example 5
 Project: lie_learn   Author: AMLab-Amsterdam   File: T1FFT.py    License: MIT License 6 votes  def synthesize(f_hat, axis=0):
"""
Compute the inverse / synthesis Fourier transform of the function f_hat : Z -> C.
The function f_hat(n) is sampled at points in a limited range -floor(N/2) <= n <= ceil(N/2) - 1

This function returns
f[k] = f(theta_k) = sum_{n=-floor(N/2)}^{ceil(N/2)-1} f_hat(n) exp(i n theta_k)
where theta_k = 2 pi k / N
for k = 0, ..., N - 1

:param f_hat:
:param axis:
:return:
"""

f_hat = ifftshift(f_hat * f_hat.shape[axis], axes=axis)
f = ifft(f_hat, axis=axis)
return f 
Example 6
 Project: scikit-dsp-comm   Author: mwickert   File: digitalcom.py    License: BSD 2-Clause "Simplified" License 6 votes  def xcorr(x1,x2,Nlags):
"""
r12, k = xcorr(x1,x2,Nlags), r12 and k are ndarray's
Compute the energy normalized cross correlation between the sequences
x1 and x2. If x1 = x2 the cross correlation is the autocorrelation.
The number of lags sets how many lags to return centered about zero
"""
K = 2*(int(np.floor(len(x1)/2)))
X1 = fft.fft(x1[:K])
X2 = fft.fft(x2[:K])
E1 = sum(abs(x1[:K])**2)
E2 = sum(abs(x2[:K])**2)
r12 = np.fft.ifft(X1*np.conj(X2))/np.sqrt(E1*E2)
k = np.arange(K) - int(np.floor(K/2))
r12 = np.fft.fftshift(r12)
idx = np.nonzero(np.ravel(abs(k) <= Nlags))
return r12[idx], k[idx] 
Example 7
 Project: scikit-kge   Author: mnick   File: util.py    License: MIT License 6 votes  def cconv(a, b):
"""
Circular convolution of vectors

Computes the circular convolution of two vectors a and b via their
fast fourier transforms

a \ast b = \mathcal{F}^{-1}(\mathcal{F}(a) \odot \mathcal{F}(b))

Parameter
---------
a: real valued array (shape N)
b: real valued array (shape N)

Returns
-------
c: real valued array (shape N), representing the circular
convolution of a and b
"""
return ifft(fft(a) * fft(b)).real 
Example 8
 Project: scikit-kge   Author: mnick   File: util.py    License: MIT License 6 votes  def ccorr(a, b):
"""
Circular correlation of vectors

Computes the circular correlation of two vectors a and b via their
fast fourier transforms

a \ast b = \mathcal{F}^{-1}(\overline{\mathcal{F}(a)} \odot \mathcal{F}(b))

Parameter
---------
a: real valued array (shape N)
b: real valued array (shape N)

Returns
-------
c: real valued array (shape N), representing the circular
correlation of a and b
"""

return ifft(np.conj(fft(a)) * fft(b)).real 
Example 9
 Project: cesi   Author: malllabiisc   File: util.py    License: Apache License 2.0 6 votes  def cconv(a, b):
"""
Circular convolution of vectors

Computes the circular convolution of two vectors a and b via their
fast fourier transforms

a \ast b = \mathcal{F}^{-1}(\mathcal{F}(a) \odot \mathcal{F}(b))

Parameter
---------
a: real valued array (shape N)
b: real valued array (shape N)

Returns
-------
c: real valued array (shape N), representing the circular
convolution of a and b
"""
return ifft(fft(a) * fft(b)).real 
Example 10
 Project: cesi   Author: malllabiisc   File: util.py    License: Apache License 2.0 6 votes  def ccorr(a, b):
"""
Circular correlation of vectors

Computes the circular correlation of two vectors a and b via their
fast fourier transforms

a \ast b = \mathcal{F}^{-1}(\overline{\mathcal{F}(a)} \odot \mathcal{F}(b))

Parameter
---------
a: real valued array (shape N)
b: real valued array (shape N)

Returns
-------
c: real valued array (shape N), representing the circular
correlation of a and b
"""

return ifft(np.conj(fft(a)) * fft(b)).real 
Example 11
 Project: pyoptools   Author: cihologramas   File: frft.py    License: GNU General Public License v3.0 6 votes  def _frft2(x, alpha):
assert x.ndim == 2, "x must be a 2 dimensional array"
m, n = x.shape
# TODO please remove this confusing comment. Is it 'm' or 'm-1' ?
# TODO If 'p = m', more code cleaning is easy to do.
p = m  # m-1 # deveria incrementarse el sigiente pow
y = zeros((2 * p, n), dtype=complex)
z = zeros((2 * p, n), dtype=complex)

j = indices(z.shape)
y[(p - m) // 2 : (p + m) // 2, :] = x * exp(
-1.0j * pi * (j[0:m] ** 2) * float(alpha) / m
)

z[0:m, :] = exp(1.0j * pi * (j[0:m] ** 2) * float(alpha) / m)
z[-m:, :] = exp(1.0j * pi * ((j[-m:] - 2 * p) ** 2) * float(alpha) / m)

d = exp(-1.0j * pi * j ** 2 ** float(alpha) / m) * ifft(
fft(y, axis=0) * fft(z, axis=0), axis=0
)

return d[0:m]

# TODO better docstring 
Example 12
 Project: Splunking-Crime   Author: nccgroup   File: fftarma.py    License: GNU Affero General Public License v3.0 6 votes  def filter(self, x):
'''
filter a timeseries with the ARMA filter

padding with zero is missing, in example I needed the padding to get
initial conditions identical to direct filter

Initial filtered observations differ from filter2 and signal.lfilter, but
at end they are the same.

--------
tsa.filters.fftconvolve

'''
n = x.shape
if n == self.fftarma:
fftarma = self.fftarma
else:
fftarma = self.fftma(n) / self.fftar(n)
tmpfft = fftarma * fft.fft(x)
return fft.ifft(tmpfft) 
Example 13
 Project: Splunking-Crime   Author: nccgroup   File: fftarma.py    License: GNU Affero General Public License v3.0 6 votes  def invpowerspd(self, n):
'''autocovariance from spectral density

scaling is correct, but n needs to be large for numerical accuracy
maybe padding with zero in fft would be faster
without slicing it returns 2-sided autocovariance with fftshift

>>> ArmaFft([1, -0.5], [1., 0.4], 40).invpowerspd(2**8)[:10]
array([ 2.08    ,  1.44    ,  0.72    ,  0.36    ,  0.18    ,  0.09    ,
0.045   ,  0.0225  ,  0.01125 ,  0.005625])
>>> ArmaFft([1, -0.5], [1., 0.4], 40).acovf(10)
array([ 2.08    ,  1.44    ,  0.72    ,  0.36    ,  0.18    ,  0.09    ,
0.045   ,  0.0225  ,  0.01125 ,  0.005625])
'''
hw = self.fftarma(n)
return np.real_if_close(fft.ifft(hw*hw.conj()), tol=200)[:n] 
Example 14
 Project: Splunking-Crime   Author: nccgroup   File: fir_filter_design.py    License: GNU Affero General Public License v3.0 6 votes  def _dhtm(mag):
"""Compute the modified 1D discrete Hilbert transform

Parameters
----------
mag : ndarray
The magnitude spectrum. Should be 1D with an even length, and
preferably a fast length for FFT/IFFT.
"""
# Adapted based on code by Niranjan Damera-Venkata,
# Brian L. Evans and Shawn R. McCaslin (see refs for minimum_phase)
sig = np.zeros(len(mag))
# Leave Nyquist and DC at 0, knowing np.abs(fftfreq(N)[midpt]) == 0.5
midpt = len(mag) // 2
sig[1:midpt] = 1
sig[midpt+1:] = -1
# eventually if we want to support complex filters, we will need a
# np.abs() on the mag inside the log, and should remove the .real
recon = ifft(mag * np.exp(fft(sig * ifft(np.log(mag))))).real
return recon 
Example 15
 Project: kshape   Author: johnpaparrizos   File: core.py    License: MIT License 6 votes  def _ncc_c(x, y):
"""
>>> _ncc_c([1,2,3,4], [1,2,3,4])
array([ 0.13333333,  0.36666667,  0.66666667,  1.        ,  0.66666667,
0.36666667,  0.13333333])
>>> _ncc_c([1,1,1], [1,1,1])
array([ 0.33333333,  0.66666667,  1.        ,  0.66666667,  0.33333333])
>>> _ncc_c([1,2,3], [-1,-1,-1])
array([-0.15430335, -0.46291005, -0.9258201 , -0.77151675, -0.46291005])
"""
den = np.array(norm(x) * norm(y))
den[den == 0] = np.Inf

x_len = len(x)
fft_size = 1 << (2*x_len-1).bit_length()
cc = ifft(fft(x, fft_size) * np.conj(fft(y, fft_size)))
cc = np.concatenate((cc[-(x_len-1):], cc[:x_len]))
return np.real(cc) / den 
Example 16
 Project: ocelot   Author: ocelot-collab   File: csr.py    License: GNU General Public License v3.0 5 votes  def csr_convolution(a, b):
P = len(a)
Q = len(b)
L = P + Q - 1
K = 2 ** nextpow2(L)
c = c[0:L-1].real
return c 
Example 17
 Project: Computable   Author: ktraunmueller   File: bench_basic.py    License: MIT License 5 votes  def bench_random(self):
from numpy.fft import ifft as numpy_ifft
print()
print('       Inverse Fast Fourier Transform')
print('===============================================')
print('      |     real input    |    complex input   ')
print('-----------------------------------------------')
print(' size |  scipy  |  numpy  |  scipy  |  numpy  ')
print('-----------------------------------------------')
for size,repeat in [(100,7000),(1000,2000),
(256,10000),
(512,10000),
(1024,1000),
(2048,1000),
(2048*2,500),
(2048*4,500),
]:
print('%5s' % size, end=' ')
sys.stdout.flush()

for x in [random([size]).astype(double),
random([size]).astype(cdouble)+random([size]).astype(cdouble)*1j
]:
if size > 500:
y = ifft(x)
else:
y = direct_idft(x)
assert_array_almost_equal(ifft(x),y)
print('|%8.2f' % measure('ifft(x)',repeat), end=' ')
sys.stdout.flush()

assert_array_almost_equal(numpy_ifft(x),y)
print('|%8.2f' % measure('numpy_ifft(x)',repeat), end=' ')
sys.stdout.flush()

print(' (secs for %s calls)' % (repeat))
sys.stdout.flush() 
Example 18
 Project: Computable   Author: ktraunmueller   File: test_basic.py    License: MIT License 5 votes  def test_djbfft(self):
from numpy.fft import ifft as numpy_ifft
for i in range(2,14):
n = 2**i
x = list(range(n))
x1 = zeros((n,),dtype=cdouble)
x1 = x
for k in range(1, n//2):
x1[k] = x[2*k-1]+1j*x[2*k]
x1[n-k] = x[2*k-1]-1j*x[2*k]
x1[n//2] = x[-1]
y1 = numpy_ifft(x1)
y = fftpack.drfft(x,direction=-1)
assert_array_almost_equal(y,y1) 
Example 19
 Project: Computable   Author: ktraunmueller   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_gaussian_real01(self):
for shape in [(32, 16), (31, 15)]:
for type in [numpy.float32, numpy.float64]:
a = numpy.zeros(shape, type)
a[0, 0] = 1.0
a = fft.rfft(a, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_gaussian(a, [5.0, 2.5],
shape, 0)
a = fft.ifft(a, shape, 1)
a = fft.irfft(a, shape, 0)
assert_almost_equal(ndimage.sum(a), 1) 
Example 20
 Project: Computable   Author: ktraunmueller   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_gaussian_complex01(self):
for shape in [(32, 16), (31, 15)]:
for type in [numpy.complex64, numpy.complex128]:
a = numpy.zeros(shape, type)
a[0, 0] = 1.0
a = fft.fft(a, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_gaussian(a, [5.0, 2.5], -1,
0)
a = fft.ifft(a, shape, 1)
a = fft.ifft(a, shape, 0)
assert_almost_equal(ndimage.sum(a.real), 1.0) 
Example 21
 Project: Computable   Author: ktraunmueller   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_uniform_real01(self):
for shape in [(32, 16), (31, 15)]:
for type in [numpy.float32, numpy.float64]:
a = numpy.zeros(shape, type)
a[0, 0] = 1.0
a = fft.rfft(a, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_uniform(a, [5.0, 2.5],
shape, 0)
a = fft.ifft(a, shape, 1)
a = fft.irfft(a, shape, 0)
assert_almost_equal(ndimage.sum(a), 1.0) 
Example 22
 Project: Computable   Author: ktraunmueller   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_shift_real01(self):
for shape in [(32, 16), (31, 15)]:
for dtype in [numpy.float32, numpy.float64]:
expected = numpy.arange(shape * shape, dtype=dtype)
expected.shape = shape
a = fft.rfft(expected, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_shift(a, [1, 1], shape, 0)
a = fft.ifft(a, shape, 1)
a = fft.irfft(a, shape, 0)
assert_array_almost_equal(a[1:, 1:], expected[:-1, :-1])
assert_array_almost_equal(a.imag, numpy.zeros(shape)) 
Example 23
 Project: Computable   Author: ktraunmueller   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_shift_complex01(self):
for shape in [(32, 16), (31, 15)]:
for type in [numpy.complex64, numpy.complex128]:
expected = numpy.arange(shape * shape,
dtype=type)
expected.shape = shape
a = fft.fft(expected, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_shift(a, [1, 1], -1, 0)
a = fft.ifft(a, shape, 1)
a = fft.ifft(a, shape, 0)
assert_array_almost_equal(a.real[1:, 1:], expected[:-1, :-1])
assert_array_almost_equal(a.imag, numpy.zeros(shape)) 
Example 24
 Project: Computable   Author: ktraunmueller   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_ellipsoid_real01(self):
for shape in [(32, 16), (31, 15)]:
for type in [numpy.float32, numpy.float64]:
a = numpy.zeros(shape, type)
a[0, 0] = 1.0
a = fft.rfft(a, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_ellipsoid(a, [5.0, 2.5],
shape, 0)
a = fft.ifft(a, shape, 1)
a = fft.irfft(a, shape, 0)
assert_almost_equal(ndimage.sum(a), 1.0) 
Example 25
 Project: Computable   Author: ktraunmueller   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_ellipsoid_complex01(self):
for shape in [(32, 16), (31, 15)]:
for type in [numpy.complex64, numpy.complex128]:
a = numpy.zeros(shape, type)
a[0, 0] = 1.0
a = fft.fft(a, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_ellipsoid(a, [5.0, 2.5], -1,
0)
a = fft.ifft(a, shape, 1)
a = fft.ifft(a, shape, 0)
assert_almost_equal(ndimage.sum(a.real), 1.0) 
Example 26
 Project: pyECO   Author: StrangerZhang   File: scale_filter.py    License: MIT License 5 votes  def track(self, im, pos, base_target_sz, current_scale_factor):
"""
track the scale using the scale filter
"""
# get scale filter features
scales = current_scale_factor * self.scale_size_factors
xs = self._extract_scale_sample(im, pos, base_target_sz, scales, self.scale_model_sz)

# project
xs = self.basis.dot(xs) * self.window

# get scores
xsf = fft(xs, axis=1)
scale_responsef = np.sum(self.sf_num * xsf, 0) / (self.sf_den + config.lamBda)
interp_scale_response = np.real(ifft(resize_dft(scale_responsef, config.number_of_interp_scales)))
recovered_scale_index = np.argmax(interp_scale_response)
if config.do_poly_interp:
# fit a quadratic polynomial to get a refined scale estimate
id1 = (recovered_scale_index - 1) % config.number_of_interp_scales
id2 = (recovered_scale_index + 1) % config.number_of_interp_scales
poly_x = np.array([self.interp_scale_factors[id1], self.interp_scale_factors[recovered_scale_index], self.interp_scale_factors[id2]])
poly_y = np.array([interp_scale_response[id1], interp_scale_response[recovered_scale_index], interp_scale_response[id2]])
poly_A = np.array([[poly_x**2, poly_x, 1],
[poly_x**2, poly_x, 1],
[poly_x**2, poly_x, 1]], dtype=np.float32)
poly = np.linalg.inv(poly_A).dot(poly_y.T)
scale_change_factor = - poly / (2 * poly)
else:
scale_change_factor = self.interp_scale_factors[recovered_scale_index]
return scale_change_factor 
Example 27
 Project: GraphicDesignPatternByPython   Author: Relph1119   File: test_basic.py    License: MIT License 5 votes  def test_djbfft(self):
from numpy.fft import ifft as numpy_ifft
for i in range(2,14):
n = 2**i
x = list(range(n))
x1 = zeros((n,),dtype=cdouble)
x1 = x
for k in range(1, n//2):
x1[k] = x[2*k-1]+1j*x[2*k]
x1[n-k] = x[2*k-1]-1j*x[2*k]
x1[n//2] = x[-1]
y1 = numpy_ifft(x1)
y = fftpack.drfft(x,direction=-1)
assert_array_almost_equal(y,y1) 
Example 28
 Project: GraphicDesignPatternByPython   Author: Relph1119   File: test_max_len_seq.py    License: MIT License 5 votes  def test_mls_output(self):
# define some alternate working taps
alt_taps = {2: , 3: , 4: , 5: [4, 3, 2], 6: [5, 4, 1], 7: ,
8: [7, 5, 3]}
# assume the other bit levels work, too slow to test higher orders...
for nbits in range(2, 8):
for state in [None, np.round(np.random.rand(nbits))]:
for taps in [None, alt_taps[nbits]]:
if state is not None and np.all(state == 0):
state = 1  # they can't all be zero
orig_m = max_len_seq(nbits, state=state,
taps=taps)
m = 2. * orig_m - 1.  # convert to +/- 1 representation
# First, make sure we got all 1's or -1
err_msg = "mls had non binary terms"
assert_array_equal(np.abs(m), np.ones_like(m),
err_msg=err_msg)
# Test via circular cross-correlation, which is just mult.
# in the frequency domain with one signal conjugated
tester = np.real(ifft(fft(m) * np.conj(fft(m))))
out_len = 2**nbits - 1
# impulse amplitude == test_len
err_msg = "mls impulse has incorrect value"
assert_allclose(tester, out_len, err_msg=err_msg)
err_msg = "mls steady-state has incorrect value"
assert_allclose(tester[1:], -1 * np.ones(out_len - 1),
err_msg=err_msg)
# let's do the split thing using a couple options
for n in (1, 2**(nbits - 1)):
m1, s1 = max_len_seq(nbits, state=state, taps=taps,
length=n)
m2, s2 = max_len_seq(nbits, state=s1, taps=taps,
length=1)
m3, s3 = max_len_seq(nbits, state=s2, taps=taps,
length=out_len - n - 1)
new_m = np.concatenate((m1, m2, m3))
assert_array_equal(orig_m, new_m) 
Example 29
 Project: GraphicDesignPatternByPython   Author: Relph1119   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_gaussian_real01(self):
for shape in [(32, 16), (31, 15)]:
for type_, dec in zip([numpy.float32, numpy.float64], [6, 14]):
a = numpy.zeros(shape, type_)
a[0, 0] = 1.0
a = fft.rfft(a, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_gaussian(a, [5.0, 2.5], shape, 0)
a = fft.ifft(a, shape, 1)
a = fft.irfft(a, shape, 0)
assert_almost_equal(ndimage.sum(a), 1, decimal=dec) 
Example 30
 Project: GraphicDesignPatternByPython   Author: Relph1119   File: test_ndimage.py    License: MIT License 5 votes  def test_fourier_gaussian_complex01(self):
for shape in [(32, 16), (31, 15)]:
for type_, dec in zip([numpy.complex64, numpy.complex128], [6, 14]):
a = numpy.zeros(shape, type_)
a[0, 0] = 1.0
a = fft.fft(a, shape, 0)
a = fft.fft(a, shape, 1)
a = ndimage.fourier_gaussian(a, [5.0, 2.5], -1, 0)
a = fft.ifft(a, shape, 1)
a = fft.ifft(a, shape, 0)
assert_almost_equal(ndimage.sum(a.real), 1.0, decimal=dec)