def test_matrix8(self): from numpy.lib.stride_tricks import as_strided x = self.xd1[:10].copy() y = as_strided(x, shape=(4,4,), strides=(2*x.itemsize, x.itemsize)) f1 = mkl_fft.fft(y) f2 = mkl_fft.fft(y.copy()) assert_allclose(f1, f2, atol=1e-15, rtol=1e-7)
def test_matrix7(self): x = self.ad2.copy() f1 = mkl_fft.fft(x) f2 = np.array([ mkl_fft.fft(x[i]) for i in range(x.shape[0])]) assert_allclose(f1, f2) f1 = mkl_fft.fft(x, axis=0) f2 = np.array([ mkl_fft.fft(x[:, i]) for i in range(x.shape[1])]).T assert_allclose(f1, f2)
def test_vector1(self): """check that mkl_fft gives the same result of numpy.fft""" f1 = mkl_fft.fft(self.xz1) f2 = np_fft.fft(self.xz1) assert_allclose(f1,f2, rtol=1e-7, atol=2e-12) f1 = mkl_fft.fft(self.xc1) f2 = np_fft.fft(self.xc1) assert_allclose(f1,f2, rtol=2e-6, atol=2e-6)
def test_vector9(self): "works on subtypes of ndarray" mask = np.zeros(self.xd1.shape, dtype='int') mask[1] = 1 mask[-2] = 1 x = np.ma.masked_array(self.xd1, mask=mask) f1 = mkl_fft.fft(x) f2 = mkl_fft.fft(self.xd1) assert_allclose(f1, f2)
def test_cf_contig(self): """fft of F-contiguous array is the same as of C-contiguous with same data""" for ar in [self.ad, self.af, self.az, self.ac]: r_tol, a_tol = _get_rtol_atol(ar) d_ccont = ar.copy() d_fcont = np.asfortranarray(d_ccont) f1 = mkl_fft.fft(d_ccont) f2 = mkl_fft.fft(d_fcont) assert_allclose(f1, f2, rtol=r_tol, atol=a_tol)
def test_matrix1(self): """fftn equals repeated fft""" for ar in [self.md, self.mz, self.mf, self.mc]: r_tol, a_tol = _get_rtol_atol(ar) d = ar.copy() t1 = mkl_fft.fftn(d) t2 = mkl_fft.fft(mkl_fft.fft(d, axis=0), axis=1) t3 = mkl_fft.fft(mkl_fft.fft(d, axis=1), axis=0) assert_allclose(t1, t2, rtol=r_tol, atol=a_tol, err_msg = "failed test for dtype {}, max abs diff: {}".format(d.dtype, np.max(np.abs(t1-t2)))) assert_allclose(t1, t3, rtol=r_tol, atol=a_tol, err_msg = "failed test for dtype {}, max abs diff: {}".format(d.dtype, np.max(np.abs(t1-t3))))
def test_array6(self): """Inputs with Fortran layout are handled correctly, issue 29""" z = self.az3 z = z.astype(z.dtype, order='F') y1 = mkl_fft.fft(z, axis=0) y2 = mkl_fft.fft(self.az3, axis=0) assert_allclose(y1, y2, atol=2e-15) y1 = mkl_fft.fft(z, axis=-1) y2 = mkl_fft.fft(self.az3, axis=-1) assert_allclose(y1, y2, atol=2e-15)
def test_vector6(self): "fft in place" x = self.xz1.copy() f1 = mkl_fft.fft(x, overwrite_x=True) assert_(not _datacopied(f1, x)) # this is in-place x = self.xz1.copy() f1 = mkl_fft.fft(x[::-2], overwrite_x=True) assert_( not np.allclose(x, self.xz1) ) # this is also in-place assert_( np.allclose(x[-2::-2], self.xz1[-2::-2]) ) assert_( np.allclose(x[-1::-2], f1) )
def IFFT_t_2(self, A): if MKL_AVAILABLE: if global_variables.PRE_FFTSHIFT: return mkl_fft.fft(A) else: return ifftshift(mkl_fft.fft(fftshift(A))) else: if global_variables.PRE_FFTSHIFT: return scipy.fftpack.fft(A) else: return ifftshift(scipy.fftpack.fft(fftshift(A)))
def test_vector4(self): "fft of strided is same as fft of contiguous copy" x = self.xz1[::2] f1 = mkl_fft.fft(x) f2 = mkl_fft.fft(x.copy()) assert_(np.allclose(f1,f2)) x = self.xz1[::-1] f1 = mkl_fft.fft(x) f2 = mkl_fft.fft(x.copy()) assert_(np.allclose(f1,f2))
def test_vector10(self): "check n for real arrays" x = self.xd1[:8].copy() f1 = mkl_fft.fft(x, n = 7) f2 = mkl_fft.fft(self.xd1[:7]) assert_allclose(f1, f2) f1 = mkl_fft.fft(x, n = 9) y = self.xd1[:9].copy() y[-1] = 0.0 f2 = mkl_fft.fft(y) assert_allclose(f1, f2)
def test_vector11(self): "check n for complex arrays" x = self.xz1[:8].copy() f1 = mkl_fft.fft(x, n = 7) f2 = mkl_fft.fft(self.xz1[:7]) assert_allclose(f1, f2) f1 = mkl_fft.fft(x, n = 9) y = self.xz1[:9].copy() y[-1] = 0.0 + 0.0j f2 = mkl_fft.fft(y) assert_allclose(f1, f2)
def test_scale_1d_vector(self): X = np.ones(128, dtype='d') f1 = mkl_fft.fft(X, forward_scale=0.25) f2 = mkl_fft.fft(X) r_tol, a_tol = _get_rtol_atol(X) assert_allclose(4*f1, f2, rtol=r_tol, atol=a_tol) X1 = mkl_fft.ifft(f1, forward_scale=0.25) assert_allclose(X, X1, rtol=r_tol, atol=a_tol) f3 = mkl_fft.rfft(X, forward_scale=0.5) X2 = mkl_fft.irfft(f3, forward_scale=0.5) assert_allclose(X, X2, rtol=r_tol, atol=a_tol)
def test_scale_1d_array(self): X = np.ones((8, 4, 4,), dtype='d') f1 = mkl_fft.fft(X, axis=1, forward_scale=0.25) f2 = mkl_fft.fft(X, axis=1) r_tol, a_tol = _get_rtol_atol(X) assert_allclose(4*f1, f2, rtol=r_tol, atol=a_tol) X1 = mkl_fft.ifft(f1, axis=1, forward_scale=0.25) assert_allclose(X, X1, rtol=r_tol, atol=a_tol) f3 = mkl_fft.rfft(X, axis=0, forward_scale=0.5) X2 = mkl_fft.irfft(f3, axis=0, forward_scale=0.5) assert_allclose(X, X2, rtol=r_tol, atol=a_tol)
def fft(a, overwrite_x = False): """Computes fft on a matrix of shape (..., n). This is identical to np.fft2(a) Parameters ---------- a : array_like Input array (must be complex). overwrite_x : bool Specifies whether original array can be destroyed (for inplace transform) Returns ------- out : complex ndarray Result of the transformation along the (-4,-3) axes. """ a = np.asarray(a, dtype = CDTYPE) libname = DTMMConfig["fftlib"] if libname == "mkl_fft": return mkl_fft.fft(a, overwrite_x = overwrite_x) elif libname == "scipy": return spfft.fft(a, overwrite_x = overwrite_x) elif libname == "numpy": return npfft.fft(a) elif libname == "pyfftw": return pyfftw.interfaces.scipy_fft.fft(a, overwrite_x = overwrite_x) else: #default implementation is numpy return npfft.fft(a)
def mkl_fft1d(a): n,m = a.shape b = np.zeros((n,m),dtype=np.complex128) for i in xrange(m): b[:,i] = mkl_fft.fft(a[:,i]+0j) return b
def test_vector3(self): "fft(ifft(x)) is identity" f1 = mkl_fft.ifft(self.xz1) f2 = mkl_fft.fft(f1) assert_(np.allclose(self.xz1,f2)) f1 = mkl_fft.ifft(self.xc1) f2 = mkl_fft.fft(f1) assert_( np.allclose(self.xc1,f2)) f1 = mkl_fft.ifft(self.xd1) f2 = mkl_fft.fft(f1) assert_( np.allclose(self.xd1,f2)) f1 = mkl_fft.ifft(self.xf1) f2 = mkl_fft.fft(f1) assert_( np.allclose(self.xf1, f2, atol = 2.0e-7))
def mfft(f): M = f.shape[0] N = f.shape[1] NS = N - 1 N2 = int(N / 2) fh = fft(f) temp = np.empty((M, NS), dtype=complex) temp[:, :N2] = fh[:, :N2] temp[:, N2:] = fh[:, N2 + 1:] return temp
def plot_wavenum_evol(self, label): cutoff = int(self.size / 2) amplitudes = np.absolute(fft(self.phi)[0:cutoff]) wavenumbers = np.argmax(amplitudes, axis=-1) plt.plot(wavenumbers) plt.xlabel(r'$t$') plt.ylabel(r'$n$') plt.tight_layout() plt.savefig('{}_wavenum.pdf'.format(label)) plt.close()
def _fft(a, overwrite_x=False): libname = CDDMConfig["fftlib"] if libname == "mkl_fft": return mkl_fft.fft(a, overwrite_x=overwrite_x) elif libname == "scipy": return spfft.fft(a, overwrite_x=overwrite_x) elif libname == "numpy": return np.fft.fft(a) elif libname == "pyfftw": return fftw.scipy_fftpack.fft(a, overwrite_x=overwrite_x)
def test_fft(self): n_tests = 1000 n_max = 2 d_max = 100 norm = 'ortho' inplace = True scrambled = True passed = True for i in range(n_tests): ndim = np.random.randint(1, high=n_max + 1) axis = np.random.randint(0, high=ndim) dims = np.random.randint(1, high=d_max + 1, size=(ndim)) x = np.random.normal(size=dims) + 1j * np.random.normal(size=dims) if inplace: X = x.copy() fft(X, axis=axis, norm=norm, out=X, scrambled=scrambled) else: X = fft(x, axis=axis, norm=norm, scrambled=scrambled) Y = np.fft.fft(x, axis=axis, norm=norm) x_ = ifft(X, axis=axis, norm=norm) if not np.allclose(X, Y) and not scrambled: print( ' Failed forward with ndim=%d axis=%d dims=' % (ndim, axis), dims) passed = False if not np.allclose(x, x_): print( ' Failed backward with ndim=%d axis=%d dims=' % (ndim, axis), dims) passed = False self.assertTrue(passed)
def test_fft(self): n_tests = 1000 n_max = 2 d_max = 100 norm = 'ortho' inplace = True scrambled = True passed = True for i in range(n_tests): ndim = np.random.randint(1,high=n_max+1) axis = np.random.randint(0,high=ndim) dims = np.random.randint(1,high=d_max+1,size=(ndim)) x = np.random.normal(size=dims) + 1j*np.random.normal(size=dims) if inplace: X = x.copy() fft(X, axis=axis, norm=norm, out=X, scrambled=scrambled) else: X = fft(x, axis=axis, norm=norm, scrambled=scrambled) Y = np.fft.fft(x, axis=axis, norm=norm) x_ = ifft(X, axis=axis, norm=norm) if not np.allclose(X,Y) and not scrambled: print(' Failed forward with ndim=%d axis=%d dims=' % (ndim, axis), dims) passed = False if not np.allclose(x, x_): print(' Failed backward with ndim=%d axis=%d dims=' % (ndim, axis), dims) passed = False self.assertTrue(passed)
def hilbert(signal: np.ndarray) -> np.ndarray: """ hilbert(signal) calculate the analytic signal using the `Hilbert transform` (same with scipy.signal.hilbert) .. math:: S_a = S + iS_H where S_H is the hilbert transform of the signal Parameters ---------- signal : np.ndarray signal Returns ------- np.ndarray :math:'s + s_{H} i' """ @njit def _modifyfft(x: np.ndarray) -> np.ndarray: """used by the function hilbert Parameters ---------- x : np.ndarray [description] Returns ------- np.ndarray [description] """ N = x.size if N % 2 == 0: x[1:N // 2] = x[1:N // 2] * 2 x[N // 2 + 1:] = 0 else: x[1:(N + 1) // 2] = x[1:(N + 1) // 2] * 2 x[(N + 1) // 2:] = 0 return x Xf = fft(signal) Xf = _modifyfft(Xf) x = ifft(Xf) return x
def test_array5(self): """Inputs with zero strides are handled correctly""" z = self.az3 z1 = z[np.newaxis] f1 = mkl_fft.fft(z1, axis=-1) f2 = mkl_fft.fft(z1.reshape(z1.shape), axis=-1) assert_allclose(f1, f2, atol=2e-15) z1 = z[:, np.newaxis] f1 = mkl_fft.fft(z1, axis=-1) f2 = mkl_fft.fft(z1.reshape(z1.shape), axis=-1) assert_allclose(f1, f2, atol=2e-15) z1 = z[:, :, np.newaxis] f1 = mkl_fft.fft(z1, axis=-1) f2 = mkl_fft.fft(z1.reshape(z1.shape), axis=-1) assert_allclose(f1, f2, atol=2e-15) z1 = z[:, :, :, np.newaxis] f1 = mkl_fft.fft(z1, axis=-1) f2 = mkl_fft.fft(z1.reshape(z1.shape), axis=-1) assert_allclose(f1, f2, atol=2e-15)
def test_conv_sub_1d(ds=1): N = 2**12 # signal - 2-d array N x K, where K - number of signals signal = np.random.normal(size = (N, 5)) signal_fft = mkl_fft.fft(signal.T).T f = gabor(N, 1, 1) signal_filtered_ds = conv_sub_1d(signal_fft, f, ds = ds) _, ax = plt.subplots(1, 2, figsize = (10, 4)) ax[0].plot(signal[:,0]) ax[0].set_title('Initial signal: {}'.format(signal.shape)) ax[1].plot(signal_filtered_ds[:,0]) ax[1].set_title('Filtered downsampled signal: {}'.format( signal_filtered_ds.shape)) plt.show()
def test_fft_truncation(self): n_tests = 1000 n_max = 2 d_max = 100 norm = None inplace = False scrambled = False passed = True for i in range(n_tests): ndim = np.random.randint(1, high=n_max + 1) axis = np.random.randint(0, high=ndim) dims = np.random.randint(2, high=d_max + 1, size=(ndim)) x = np.random.normal(size=dims) + 1j * np.random.normal(size=dims) x_trunc = np.swapaxes(x, axis, -1)[..., :dims[axis] // 2] x_trunc = np.swapaxes(x_trunc, -1, axis) X = fft(x, axis=axis, n=dims[axis] // 2) Y = np.fft.fft(x, axis=axis, n=dims[axis] // 2) x_ = ifft(X, axis=axis, norm=norm) if not np.allclose(X, Y) and not scrambled: print( ' Failed forward with ndim=%d axis=%d dims=' % (ndim, axis), dims) passed = False if not np.allclose(x_trunc, x_): print( ' Failed backward with ndim=%d axis=%d dims=' % (ndim, axis), dims) passed = False self.assertTrue(passed)
def fft(x, n=None, axis=-1, overwrite_input=False, extra_info=None): return mkl_fft.fft(x, n=n, axis=axis, overwrite_x=overwrite_input)
def test_matrix4(self): x = self.az2.copy() f1 = mkl_fft.fft(x[::3,::-1]) f2 = mkl_fft.fft(x[::3,::-1], overwrite_x=True) assert_allclose(f1, f2)
def test_matrix6(self): x = self.ad2; f1 = mkl_fft.ifft(x) f2 = mkl_fft.fft(f1) assert_allclose(x, f2, atol=1e-10)
shape = (len(epsilons), len(us)) means = np.empty(shape, dtype='float64') error_bars = np.zeros(shape, dtype='float64') for (i, epsilon) in enumerate(epsilons): for (k, u) in enumerate(us): label = 'u_{}_epsilon_{}{}'.format(u, epsilon, indices[k]) print(label) solver = StoEvolution1D() solver.load(label) # solver.plot_evolution(label, t_size=200, x_size=400) # solver.plot_wavenum_evol(label) phi = solver.phi[-average_over:] cutoff = int(length / 2) amplitudes = np.absolute(fft(phi)[0:cutoff]) wavenumbers = 2 * np.argmax(amplitudes, axis=-1) means[i, k] = np.mean(wavenumbers) error_bars[i, k] = np.std(wavenumbers) plt.rc('text', usetex=True) plt.rc('font', family='serif', size=18) qc = np.sqrt(solver.a / (2 * solver.k)) x = np.log(us) colors = ['tab:blue', 'tab:orange'] for (i, epsilon) in enumerate(epsilons): y = np.log(length) - np.log(means[i]) poly = np.poly1d(np.polyfit(x, y, 1)) plt.errorbar(x, y, yerr=error_bars[i] / means[i],
def test_array4(self): x = self.ad3 for ax in range(x.ndim): f1 = mkl_fft.ifft(x, axis = ax) f2 = mkl_fft.fft(f1, axis = ax) assert_allclose(f2, x, atol=2e-15)